#[doc = "Register `CONTROL` reader"]
pub type R = crate::R<ControlSpec>;
#[doc = "Register `CONTROL` writer"]
pub type W = crate::W<ControlSpec>;
#[doc = "Lock control\n\nValue on reset: 2"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum LockCtrl {
    #[doc = "1: Locked"]
    Locked = 1,
    #[doc = "2: Unlocked"]
    Unlocked = 2,
}
impl From<LockCtrl> for u8 {
    #[inline(always)]
    fn from(variant: LockCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for LockCtrl {
    type Ux = u8;
}
impl crate::IsEnum for LockCtrl {}
#[doc = "Field `LOCK_CTRL` reader - Lock control"]
pub type LockCtrlR = crate::FieldReader<LockCtrl>;
impl LockCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<LockCtrl> {
        match self.bits {
            1 => Some(LockCtrl::Locked),
            2 => Some(LockCtrl::Unlocked),
            _ => None,
        }
    }
    #[doc = "Locked"]
    #[inline(always)]
    pub fn is_locked(&self) -> bool {
        *self == LockCtrl::Locked
    }
    #[doc = "Unlocked"]
    #[inline(always)]
    pub fn is_unlocked(&self) -> bool {
        *self == LockCtrl::Unlocked
    }
}
#[doc = "Field `LOCK_CTRL` writer - Lock control"]
pub type LockCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 2, LockCtrl>;
impl<'a, REG> LockCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Locked"]
    #[inline(always)]
    pub fn locked(self) -> &'a mut crate::W<REG> {
        self.variant(LockCtrl::Locked)
    }
    #[doc = "Unlocked"]
    #[inline(always)]
    pub fn unlocked(self) -> &'a mut crate::W<REG> {
        self.variant(LockCtrl::Unlocked)
    }
}
#[doc = "TIMEOUT fault control\n\nValue on reset: 4"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum TimeoutCtrl {
    #[doc = "1: Enable reset"]
    EnableReset = 1,
    #[doc = "2: Enable interrupt"]
    EnableInterrupt = 2,
    #[doc = "4: Disable both reset and interrupt"]
    DisableBoth = 4,
}
impl From<TimeoutCtrl> for u8 {
    #[inline(always)]
    fn from(variant: TimeoutCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for TimeoutCtrl {
    type Ux = u8;
}
impl crate::IsEnum for TimeoutCtrl {}
#[doc = "Field `TIMEOUT_CTRL` reader - TIMEOUT fault control"]
pub type TimeoutCtrlR = crate::FieldReader<TimeoutCtrl>;
impl TimeoutCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<TimeoutCtrl> {
        match self.bits {
            1 => Some(TimeoutCtrl::EnableReset),
            2 => Some(TimeoutCtrl::EnableInterrupt),
            4 => Some(TimeoutCtrl::DisableBoth),
            _ => None,
        }
    }
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn is_enable_reset(&self) -> bool {
        *self == TimeoutCtrl::EnableReset
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn is_enable_interrupt(&self) -> bool {
        *self == TimeoutCtrl::EnableInterrupt
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn is_disable_both(&self) -> bool {
        *self == TimeoutCtrl::DisableBoth
    }
}
#[doc = "Field `TIMEOUT_CTRL` writer - TIMEOUT fault control"]
pub type TimeoutCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 3, TimeoutCtrl>;
impl<'a, REG> TimeoutCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn enable_reset(self) -> &'a mut crate::W<REG> {
        self.variant(TimeoutCtrl::EnableReset)
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn enable_interrupt(self) -> &'a mut crate::W<REG> {
        self.variant(TimeoutCtrl::EnableInterrupt)
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn disable_both(self) -> &'a mut crate::W<REG> {
        self.variant(TimeoutCtrl::DisableBoth)
    }
}
#[doc = "MISCOMPARE fault control\n\nValue on reset: 4"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum MiscompareCtrl {
    #[doc = "1: Enable reset"]
    EnableReset = 1,
    #[doc = "2: Enable interrupt"]
    EnableInterrupt = 2,
    #[doc = "4: Disable both reset and interrupt"]
    DisableBoth = 4,
}
impl From<MiscompareCtrl> for u8 {
    #[inline(always)]
    fn from(variant: MiscompareCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for MiscompareCtrl {
    type Ux = u8;
}
impl crate::IsEnum for MiscompareCtrl {}
#[doc = "Field `MISCOMPARE_CTRL` reader - MISCOMPARE fault control"]
pub type MiscompareCtrlR = crate::FieldReader<MiscompareCtrl>;
impl MiscompareCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<MiscompareCtrl> {
        match self.bits {
            1 => Some(MiscompareCtrl::EnableReset),
            2 => Some(MiscompareCtrl::EnableInterrupt),
            4 => Some(MiscompareCtrl::DisableBoth),
            _ => None,
        }
    }
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn is_enable_reset(&self) -> bool {
        *self == MiscompareCtrl::EnableReset
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn is_enable_interrupt(&self) -> bool {
        *self == MiscompareCtrl::EnableInterrupt
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn is_disable_both(&self) -> bool {
        *self == MiscompareCtrl::DisableBoth
    }
}
#[doc = "Field `MISCOMPARE_CTRL` writer - MISCOMPARE fault control"]
pub type MiscompareCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 3, MiscompareCtrl>;
impl<'a, REG> MiscompareCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn enable_reset(self) -> &'a mut crate::W<REG> {
        self.variant(MiscompareCtrl::EnableReset)
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn enable_interrupt(self) -> &'a mut crate::W<REG> {
        self.variant(MiscompareCtrl::EnableInterrupt)
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn disable_both(self) -> &'a mut crate::W<REG> {
        self.variant(MiscompareCtrl::DisableBoth)
    }
}
#[doc = "SEQUENCE fault control\n\nValue on reset: 4"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum SequenceCtrl {
    #[doc = "1: Enable reset"]
    EnableReset = 1,
    #[doc = "2: Enable interrupt"]
    EnableInterrupt = 2,
    #[doc = "4: Disable both reset and interrupt"]
    DisableBoth = 4,
}
impl From<SequenceCtrl> for u8 {
    #[inline(always)]
    fn from(variant: SequenceCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for SequenceCtrl {
    type Ux = u8;
}
impl crate::IsEnum for SequenceCtrl {}
#[doc = "Field `SEQUENCE_CTRL` reader - SEQUENCE fault control"]
pub type SequenceCtrlR = crate::FieldReader<SequenceCtrl>;
impl SequenceCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<SequenceCtrl> {
        match self.bits {
            1 => Some(SequenceCtrl::EnableReset),
            2 => Some(SequenceCtrl::EnableInterrupt),
            4 => Some(SequenceCtrl::DisableBoth),
            _ => None,
        }
    }
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn is_enable_reset(&self) -> bool {
        *self == SequenceCtrl::EnableReset
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn is_enable_interrupt(&self) -> bool {
        *self == SequenceCtrl::EnableInterrupt
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn is_disable_both(&self) -> bool {
        *self == SequenceCtrl::DisableBoth
    }
}
#[doc = "Field `SEQUENCE_CTRL` writer - SEQUENCE fault control"]
pub type SequenceCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 3, SequenceCtrl>;
impl<'a, REG> SequenceCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn enable_reset(self) -> &'a mut crate::W<REG> {
        self.variant(SequenceCtrl::EnableReset)
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn enable_interrupt(self) -> &'a mut crate::W<REG> {
        self.variant(SequenceCtrl::EnableInterrupt)
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn disable_both(self) -> &'a mut crate::W<REG> {
        self.variant(SequenceCtrl::DisableBoth)
    }
}
#[doc = "STATE fault control\n\nValue on reset: 4"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum StateCtrl {
    #[doc = "1: Enable reset"]
    EnableReset = 1,
    #[doc = "2: Enable interrupt"]
    EnableInterrupt = 2,
    #[doc = "4: Disable both reset and interrupt"]
    DisableBoth = 4,
}
impl From<StateCtrl> for u8 {
    #[inline(always)]
    fn from(variant: StateCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for StateCtrl {
    type Ux = u8;
}
impl crate::IsEnum for StateCtrl {}
#[doc = "Field `STATE_CTRL` reader - STATE fault control"]
pub type StateCtrlR = crate::FieldReader<StateCtrl>;
impl StateCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<StateCtrl> {
        match self.bits {
            1 => Some(StateCtrl::EnableReset),
            2 => Some(StateCtrl::EnableInterrupt),
            4 => Some(StateCtrl::DisableBoth),
            _ => None,
        }
    }
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn is_enable_reset(&self) -> bool {
        *self == StateCtrl::EnableReset
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn is_enable_interrupt(&self) -> bool {
        *self == StateCtrl::EnableInterrupt
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn is_disable_both(&self) -> bool {
        *self == StateCtrl::DisableBoth
    }
}
#[doc = "Field `STATE_CTRL` writer - STATE fault control"]
pub type StateCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 3, StateCtrl>;
impl<'a, REG> StateCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn enable_reset(self) -> &'a mut crate::W<REG> {
        self.variant(StateCtrl::EnableReset)
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn enable_interrupt(self) -> &'a mut crate::W<REG> {
        self.variant(StateCtrl::EnableInterrupt)
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn disable_both(self) -> &'a mut crate::W<REG> {
        self.variant(StateCtrl::DisableBoth)
    }
}
#[doc = "ADDRESS fault control\n\nValue on reset: 4"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum AddressCtrl {
    #[doc = "1: Enable reset"]
    EnableReset = 1,
    #[doc = "2: Enable interrupt"]
    EnableInterrupt = 2,
    #[doc = "4: Disable both reset and interrupt"]
    DisableBoth = 4,
}
impl From<AddressCtrl> for u8 {
    #[inline(always)]
    fn from(variant: AddressCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for AddressCtrl {
    type Ux = u8;
}
impl crate::IsEnum for AddressCtrl {}
#[doc = "Field `ADDRESS_CTRL` reader - ADDRESS fault control"]
pub type AddressCtrlR = crate::FieldReader<AddressCtrl>;
impl AddressCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<AddressCtrl> {
        match self.bits {
            1 => Some(AddressCtrl::EnableReset),
            2 => Some(AddressCtrl::EnableInterrupt),
            4 => Some(AddressCtrl::DisableBoth),
            _ => None,
        }
    }
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn is_enable_reset(&self) -> bool {
        *self == AddressCtrl::EnableReset
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn is_enable_interrupt(&self) -> bool {
        *self == AddressCtrl::EnableInterrupt
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn is_disable_both(&self) -> bool {
        *self == AddressCtrl::DisableBoth
    }
}
#[doc = "Field `ADDRESS_CTRL` writer - ADDRESS fault control"]
pub type AddressCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 3, AddressCtrl>;
impl<'a, REG> AddressCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Enable reset"]
    #[inline(always)]
    pub fn enable_reset(self) -> &'a mut crate::W<REG> {
        self.variant(AddressCtrl::EnableReset)
    }
    #[doc = "Enable interrupt"]
    #[inline(always)]
    pub fn enable_interrupt(self) -> &'a mut crate::W<REG> {
        self.variant(AddressCtrl::EnableInterrupt)
    }
    #[doc = "Disable both reset and interrupt"]
    #[inline(always)]
    pub fn disable_both(self) -> &'a mut crate::W<REG> {
        self.variant(AddressCtrl::DisableBoth)
    }
}
#[doc = "IRQ pause control\n\nValue on reset: 1"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum IrqPause {
    #[doc = "1: Keep the timer running"]
    RunTimer = 1,
    #[doc = "2: Stop the timer"]
    PauseTimer = 2,
}
impl From<IrqPause> for u8 {
    #[inline(always)]
    fn from(variant: IrqPause) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for IrqPause {
    type Ux = u8;
}
impl crate::IsEnum for IrqPause {}
#[doc = "Field `IRQ_PAUSE` reader - IRQ pause control"]
pub type IrqPauseR = crate::FieldReader<IrqPause>;
impl IrqPauseR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<IrqPause> {
        match self.bits {
            1 => Some(IrqPause::RunTimer),
            2 => Some(IrqPause::PauseTimer),
            _ => None,
        }
    }
    #[doc = "Keep the timer running"]
    #[inline(always)]
    pub fn is_run_timer(&self) -> bool {
        *self == IrqPause::RunTimer
    }
    #[doc = "Stop the timer"]
    #[inline(always)]
    pub fn is_pause_timer(&self) -> bool {
        *self == IrqPause::PauseTimer
    }
}
#[doc = "Field `IRQ_PAUSE` writer - IRQ pause control"]
pub type IrqPauseW<'a, REG> = crate::FieldWriter<'a, REG, 2, IrqPause>;
impl<'a, REG> IrqPauseW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Keep the timer running"]
    #[inline(always)]
    pub fn run_timer(self) -> &'a mut crate::W<REG> {
        self.variant(IrqPause::RunTimer)
    }
    #[doc = "Stop the timer"]
    #[inline(always)]
    pub fn pause_timer(self) -> &'a mut crate::W<REG> {
        self.variant(IrqPause::PauseTimer)
    }
}
#[doc = "DEBUG_HALT control\n\nValue on reset: 1"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum DebugHaltCtrl {
    #[doc = "1: Keep the timer running"]
    RunTimer = 1,
    #[doc = "2: Stop the timer"]
    PauseTimer = 2,
}
impl From<DebugHaltCtrl> for u8 {
    #[inline(always)]
    fn from(variant: DebugHaltCtrl) -> Self {
        variant as _
    }
}
impl crate::FieldSpec for DebugHaltCtrl {
    type Ux = u8;
}
impl crate::IsEnum for DebugHaltCtrl {}
#[doc = "Field `DEBUG_HALT_CTRL` reader - DEBUG_HALT control"]
pub type DebugHaltCtrlR = crate::FieldReader<DebugHaltCtrl>;
impl DebugHaltCtrlR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Option<DebugHaltCtrl> {
        match self.bits {
            1 => Some(DebugHaltCtrl::RunTimer),
            2 => Some(DebugHaltCtrl::PauseTimer),
            _ => None,
        }
    }
    #[doc = "Keep the timer running"]
    #[inline(always)]
    pub fn is_run_timer(&self) -> bool {
        *self == DebugHaltCtrl::RunTimer
    }
    #[doc = "Stop the timer"]
    #[inline(always)]
    pub fn is_pause_timer(&self) -> bool {
        *self == DebugHaltCtrl::PauseTimer
    }
}
#[doc = "Field `DEBUG_HALT_CTRL` writer - DEBUG_HALT control"]
pub type DebugHaltCtrlW<'a, REG> = crate::FieldWriter<'a, REG, 2, DebugHaltCtrl>;
impl<'a, REG> DebugHaltCtrlW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
    REG::Ux: From<u8>,
{
    #[doc = "Keep the timer running"]
    #[inline(always)]
    pub fn run_timer(self) -> &'a mut crate::W<REG> {
        self.variant(DebugHaltCtrl::RunTimer)
    }
    #[doc = "Stop the timer"]
    #[inline(always)]
    pub fn pause_timer(self) -> &'a mut crate::W<REG> {
        self.variant(DebugHaltCtrl::PauseTimer)
    }
}
impl R {
    #[doc = "Bits 0:1 - Lock control"]
    #[inline(always)]
    pub fn lock_ctrl(&self) -> LockCtrlR {
        LockCtrlR::new((self.bits & 3) as u8)
    }
    #[doc = "Bits 2:4 - TIMEOUT fault control"]
    #[inline(always)]
    pub fn timeout_ctrl(&self) -> TimeoutCtrlR {
        TimeoutCtrlR::new(((self.bits >> 2) & 7) as u8)
    }
    #[doc = "Bits 5:7 - MISCOMPARE fault control"]
    #[inline(always)]
    pub fn miscompare_ctrl(&self) -> MiscompareCtrlR {
        MiscompareCtrlR::new(((self.bits >> 5) & 7) as u8)
    }
    #[doc = "Bits 8:10 - SEQUENCE fault control"]
    #[inline(always)]
    pub fn sequence_ctrl(&self) -> SequenceCtrlR {
        SequenceCtrlR::new(((self.bits >> 8) & 7) as u8)
    }
    #[doc = "Bits 14:16 - STATE fault control"]
    #[inline(always)]
    pub fn state_ctrl(&self) -> StateCtrlR {
        StateCtrlR::new(((self.bits >> 14) & 7) as u8)
    }
    #[doc = "Bits 17:19 - ADDRESS fault control"]
    #[inline(always)]
    pub fn address_ctrl(&self) -> AddressCtrlR {
        AddressCtrlR::new(((self.bits >> 17) & 7) as u8)
    }
    #[doc = "Bits 28:29 - IRQ pause control"]
    #[inline(always)]
    pub fn irq_pause(&self) -> IrqPauseR {
        IrqPauseR::new(((self.bits >> 28) & 3) as u8)
    }
    #[doc = "Bits 30:31 - DEBUG_HALT control"]
    #[inline(always)]
    pub fn debug_halt_ctrl(&self) -> DebugHaltCtrlR {
        DebugHaltCtrlR::new(((self.bits >> 30) & 3) as u8)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("CONTROL")
            .field("lock_ctrl", &self.lock_ctrl())
            .field("timeout_ctrl", &self.timeout_ctrl())
            .field("miscompare_ctrl", &self.miscompare_ctrl())
            .field("sequence_ctrl", &self.sequence_ctrl())
            .field("state_ctrl", &self.state_ctrl())
            .field("address_ctrl", &self.address_ctrl())
            .field("irq_pause", &self.irq_pause())
            .field("debug_halt_ctrl", &self.debug_halt_ctrl())
            .finish()
    }
}
impl W {
    #[doc = "Bits 0:1 - Lock control"]
    #[inline(always)]
    pub fn lock_ctrl(&mut self) -> LockCtrlW<'_, ControlSpec> {
        LockCtrlW::new(self, 0)
    }
    #[doc = "Bits 2:4 - TIMEOUT fault control"]
    #[inline(always)]
    pub fn timeout_ctrl(&mut self) -> TimeoutCtrlW<'_, ControlSpec> {
        TimeoutCtrlW::new(self, 2)
    }
    #[doc = "Bits 5:7 - MISCOMPARE fault control"]
    #[inline(always)]
    pub fn miscompare_ctrl(&mut self) -> MiscompareCtrlW<'_, ControlSpec> {
        MiscompareCtrlW::new(self, 5)
    }
    #[doc = "Bits 8:10 - SEQUENCE fault control"]
    #[inline(always)]
    pub fn sequence_ctrl(&mut self) -> SequenceCtrlW<'_, ControlSpec> {
        SequenceCtrlW::new(self, 8)
    }
    #[doc = "Bits 14:16 - STATE fault control"]
    #[inline(always)]
    pub fn state_ctrl(&mut self) -> StateCtrlW<'_, ControlSpec> {
        StateCtrlW::new(self, 14)
    }
    #[doc = "Bits 17:19 - ADDRESS fault control"]
    #[inline(always)]
    pub fn address_ctrl(&mut self) -> AddressCtrlW<'_, ControlSpec> {
        AddressCtrlW::new(self, 17)
    }
    #[doc = "Bits 28:29 - IRQ pause control"]
    #[inline(always)]
    pub fn irq_pause(&mut self) -> IrqPauseW<'_, ControlSpec> {
        IrqPauseW::new(self, 28)
    }
    #[doc = "Bits 30:31 - DEBUG_HALT control"]
    #[inline(always)]
    pub fn debug_halt_ctrl(&mut self) -> DebugHaltCtrlW<'_, ControlSpec> {
        DebugHaltCtrlW::new(self, 30)
    }
}
#[doc = "Control Register\n\nYou can [`read`](crate::Reg::read) this register and get [`control::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`control::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct ControlSpec;
impl crate::RegisterSpec for ControlSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`control::R`](R) reader structure"]
impl crate::Readable for ControlSpec {}
#[doc = "`write(|w| ..)` method takes [`control::W`](W) writer structure"]
impl crate::Writable for ControlSpec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets CONTROL to value 0x5009_2492"]
impl crate::Resettable for ControlSpec {
    const RESET_VALUE: u32 = 0x5009_2492;
}
