#[doc = "Register `MRCC_GLB_RST1` reader"]
pub type R = crate::R<MrccGlbRst1Spec>;
#[doc = "Register `MRCC_GLB_RST1` writer"]
pub type W = crate::W<MrccGlbRst1Spec>;
#[doc = "FLEXPWM1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Flexpwm1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Flexpwm1> for bool {
    #[inline(always)]
    fn from(variant: Flexpwm1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `FLEXPWM1` reader - FLEXPWM1"]
pub type Flexpwm1R = crate::BitReader<Flexpwm1>;
impl Flexpwm1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Flexpwm1 {
        match self.bits {
            false => Flexpwm1::Disabled,
            true => Flexpwm1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Flexpwm1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Flexpwm1::Enabled
    }
}
#[doc = "Field `FLEXPWM1` writer - FLEXPWM1"]
pub type Flexpwm1W<'a, REG> = crate::BitWriter<'a, REG, Flexpwm1>;
impl<'a, REG> Flexpwm1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexpwm1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexpwm1::Enabled)
    }
}
#[doc = "OSTIMER0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Ostimer0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Ostimer0> for bool {
    #[inline(always)]
    fn from(variant: Ostimer0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OSTIMER0` reader - OSTIMER0"]
pub type Ostimer0R = crate::BitReader<Ostimer0>;
impl Ostimer0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Ostimer0 {
        match self.bits {
            false => Ostimer0::Disabled,
            true => Ostimer0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Ostimer0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Ostimer0::Enabled
    }
}
#[doc = "Field `OSTIMER0` writer - OSTIMER0"]
pub type Ostimer0W<'a, REG> = crate::BitWriter<'a, REG, Ostimer0>;
impl<'a, REG> Ostimer0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Ostimer0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Ostimer0::Enabled)
    }
}
#[doc = "ADC0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Adc0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Adc0> for bool {
    #[inline(always)]
    fn from(variant: Adc0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `ADC0` reader - ADC0"]
pub type Adc0R = crate::BitReader<Adc0>;
impl Adc0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Adc0 {
        match self.bits {
            false => Adc0::Disabled,
            true => Adc0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Adc0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Adc0::Enabled
    }
}
#[doc = "Field `ADC0` writer - ADC0"]
pub type Adc0W<'a, REG> = crate::BitWriter<'a, REG, Adc0>;
impl<'a, REG> Adc0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc0::Enabled)
    }
}
#[doc = "ADC1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Adc1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Adc1> for bool {
    #[inline(always)]
    fn from(variant: Adc1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `ADC1` reader - ADC1"]
pub type Adc1R = crate::BitReader<Adc1>;
impl Adc1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Adc1 {
        match self.bits {
            false => Adc1::Disabled,
            true => Adc1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Adc1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Adc1::Enabled
    }
}
#[doc = "Field `ADC1` writer - ADC1"]
pub type Adc1W<'a, REG> = crate::BitWriter<'a, REG, Adc1>;
impl<'a, REG> Adc1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc1::Enabled)
    }
}
#[doc = "CMP1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Cmp1> for bool {
    #[inline(always)]
    fn from(variant: Cmp1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CMP1` reader - CMP1"]
pub type Cmp1R = crate::BitReader<Cmp1>;
impl Cmp1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cmp1 {
        match self.bits {
            false => Cmp1::Disabled,
            true => Cmp1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Cmp1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Cmp1::Enabled
    }
}
#[doc = "Field `CMP1` writer - CMP1"]
pub type Cmp1W<'a, REG> = crate::BitWriter<'a, REG, Cmp1>;
impl<'a, REG> Cmp1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmp1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmp1::Enabled)
    }
}
#[doc = "CMP2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmp2 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Cmp2> for bool {
    #[inline(always)]
    fn from(variant: Cmp2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `CMP2` reader - CMP2"]
pub type Cmp2R = crate::BitReader<Cmp2>;
impl Cmp2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Cmp2 {
        match self.bits {
            false => Cmp2::Disabled,
            true => Cmp2::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Cmp2::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Cmp2::Enabled
    }
}
#[doc = "Field `CMP2` writer - CMP2"]
pub type Cmp2W<'a, REG> = crate::BitWriter<'a, REG, Cmp2>;
impl<'a, REG> Cmp2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmp2::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Cmp2::Enabled)
    }
}
#[doc = "DAC0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Dac0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Dac0> for bool {
    #[inline(always)]
    fn from(variant: Dac0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `DAC0` reader - DAC0"]
pub type Dac0R = crate::BitReader<Dac0>;
impl Dac0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Dac0 {
        match self.bits {
            false => Dac0::Disabled,
            true => Dac0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Dac0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Dac0::Enabled
    }
}
#[doc = "Field `DAC0` writer - DAC0"]
pub type Dac0W<'a, REG> = crate::BitWriter<'a, REG, Dac0>;
impl<'a, REG> Dac0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Dac0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Dac0::Enabled)
    }
}
#[doc = "OPAMP0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Opamp0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Opamp0> for bool {
    #[inline(always)]
    fn from(variant: Opamp0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OPAMP0` reader - OPAMP0"]
pub type Opamp0R = crate::BitReader<Opamp0>;
impl Opamp0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Opamp0 {
        match self.bits {
            false => Opamp0::Disabled,
            true => Opamp0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Opamp0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Opamp0::Enabled
    }
}
#[doc = "Field `OPAMP0` writer - OPAMP0"]
pub type Opamp0W<'a, REG> = crate::BitWriter<'a, REG, Opamp0>;
impl<'a, REG> Opamp0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp0::Enabled)
    }
}
#[doc = "OPAMP1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Opamp1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Opamp1> for bool {
    #[inline(always)]
    fn from(variant: Opamp1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OPAMP1` reader - OPAMP1"]
pub type Opamp1R = crate::BitReader<Opamp1>;
impl Opamp1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Opamp1 {
        match self.bits {
            false => Opamp1::Disabled,
            true => Opamp1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Opamp1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Opamp1::Enabled
    }
}
#[doc = "Field `OPAMP1` writer - OPAMP1"]
pub type Opamp1W<'a, REG> = crate::BitWriter<'a, REG, Opamp1>;
impl<'a, REG> Opamp1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp1::Enabled)
    }
}
#[doc = "OPAMP2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Opamp2 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Opamp2> for bool {
    #[inline(always)]
    fn from(variant: Opamp2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OPAMP2` reader - OPAMP2"]
pub type Opamp2R = crate::BitReader<Opamp2>;
impl Opamp2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Opamp2 {
        match self.bits {
            false => Opamp2::Disabled,
            true => Opamp2::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Opamp2::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Opamp2::Enabled
    }
}
#[doc = "Field `OPAMP2` writer - OPAMP2"]
pub type Opamp2W<'a, REG> = crate::BitWriter<'a, REG, Opamp2>;
impl<'a, REG> Opamp2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp2::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp2::Enabled)
    }
}
#[doc = "OPAMP3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Opamp3 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Opamp3> for bool {
    #[inline(always)]
    fn from(variant: Opamp3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OPAMP3` reader - OPAMP3"]
pub type Opamp3R = crate::BitReader<Opamp3>;
impl Opamp3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Opamp3 {
        match self.bits {
            false => Opamp3::Disabled,
            true => Opamp3::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Opamp3::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Opamp3::Enabled
    }
}
#[doc = "Field `OPAMP3` writer - OPAMP3"]
pub type Opamp3W<'a, REG> = crate::BitWriter<'a, REG, Opamp3>;
impl<'a, REG> Opamp3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp3::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Opamp3::Enabled)
    }
}
#[doc = "PORT0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Port0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Port0> for bool {
    #[inline(always)]
    fn from(variant: Port0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PORT0` reader - PORT0"]
pub type Port0R = crate::BitReader<Port0>;
impl Port0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Port0 {
        match self.bits {
            false => Port0::Disabled,
            true => Port0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Port0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Port0::Enabled
    }
}
#[doc = "Field `PORT0` writer - PORT0"]
pub type Port0W<'a, REG> = crate::BitWriter<'a, REG, Port0>;
impl<'a, REG> Port0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port0::Enabled)
    }
}
#[doc = "PORT1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Port1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Port1> for bool {
    #[inline(always)]
    fn from(variant: Port1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PORT1` reader - PORT1"]
pub type Port1R = crate::BitReader<Port1>;
impl Port1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Port1 {
        match self.bits {
            false => Port1::Disabled,
            true => Port1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Port1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Port1::Enabled
    }
}
#[doc = "Field `PORT1` writer - PORT1"]
pub type Port1W<'a, REG> = crate::BitWriter<'a, REG, Port1>;
impl<'a, REG> Port1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port1::Enabled)
    }
}
#[doc = "PORT2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Port2 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Port2> for bool {
    #[inline(always)]
    fn from(variant: Port2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PORT2` reader - PORT2"]
pub type Port2R = crate::BitReader<Port2>;
impl Port2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Port2 {
        match self.bits {
            false => Port2::Disabled,
            true => Port2::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Port2::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Port2::Enabled
    }
}
#[doc = "Field `PORT2` writer - PORT2"]
pub type Port2W<'a, REG> = crate::BitWriter<'a, REG, Port2>;
impl<'a, REG> Port2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port2::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port2::Enabled)
    }
}
#[doc = "PORT3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Port3 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Port3> for bool {
    #[inline(always)]
    fn from(variant: Port3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PORT3` reader - PORT3"]
pub type Port3R = crate::BitReader<Port3>;
impl Port3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Port3 {
        match self.bits {
            false => Port3::Disabled,
            true => Port3::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Port3::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Port3::Enabled
    }
}
#[doc = "Field `PORT3` writer - PORT3"]
pub type Port3W<'a, REG> = crate::BitWriter<'a, REG, Port3>;
impl<'a, REG> Port3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port3::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port3::Enabled)
    }
}
#[doc = "PORT4\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Port4 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Port4> for bool {
    #[inline(always)]
    fn from(variant: Port4) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PORT4` reader - PORT4"]
pub type Port4R = crate::BitReader<Port4>;
impl Port4R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Port4 {
        match self.bits {
            false => Port4::Disabled,
            true => Port4::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Port4::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Port4::Enabled
    }
}
#[doc = "Field `PORT4` writer - PORT4"]
pub type Port4W<'a, REG> = crate::BitWriter<'a, REG, Port4>;
impl<'a, REG> Port4W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port4::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Port4::Enabled)
    }
}
#[doc = "SLCD0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Slcd0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Slcd0> for bool {
    #[inline(always)]
    fn from(variant: Slcd0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `SLCD0` reader - SLCD0"]
pub type Slcd0R = crate::BitReader<Slcd0>;
impl Slcd0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Slcd0 {
        match self.bits {
            false => Slcd0::Disabled,
            true => Slcd0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Slcd0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Slcd0::Enabled
    }
}
#[doc = "Field `SLCD0` writer - SLCD0"]
pub type Slcd0W<'a, REG> = crate::BitWriter<'a, REG, Slcd0>;
impl<'a, REG> Slcd0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Slcd0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Slcd0::Enabled)
    }
}
#[doc = "FLEXCAN0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Flexcan0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Flexcan0> for bool {
    #[inline(always)]
    fn from(variant: Flexcan0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `FLEXCAN0` reader - FLEXCAN0"]
pub type Flexcan0R = crate::BitReader<Flexcan0>;
impl Flexcan0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Flexcan0 {
        match self.bits {
            false => Flexcan0::Disabled,
            true => Flexcan0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Flexcan0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Flexcan0::Enabled
    }
}
#[doc = "Field `FLEXCAN0` writer - FLEXCAN0"]
pub type Flexcan0W<'a, REG> = crate::BitWriter<'a, REG, Flexcan0>;
impl<'a, REG> Flexcan0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexcan0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexcan0::Enabled)
    }
}
#[doc = "FLEXCAN1\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Flexcan1 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Flexcan1> for bool {
    #[inline(always)]
    fn from(variant: Flexcan1) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `FLEXCAN1` reader - FLEXCAN1"]
pub type Flexcan1R = crate::BitReader<Flexcan1>;
impl Flexcan1R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Flexcan1 {
        match self.bits {
            false => Flexcan1::Disabled,
            true => Flexcan1::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Flexcan1::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Flexcan1::Enabled
    }
}
#[doc = "Field `FLEXCAN1` writer - FLEXCAN1"]
pub type Flexcan1W<'a, REG> = crate::BitWriter<'a, REG, Flexcan1>;
impl<'a, REG> Flexcan1W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexcan1::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Flexcan1::Enabled)
    }
}
#[doc = "LPI2C2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Lpi2c2 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Lpi2c2> for bool {
    #[inline(always)]
    fn from(variant: Lpi2c2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `LPI2C2` reader - LPI2C2"]
pub type Lpi2c2R = crate::BitReader<Lpi2c2>;
impl Lpi2c2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Lpi2c2 {
        match self.bits {
            false => Lpi2c2::Disabled,
            true => Lpi2c2::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Lpi2c2::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Lpi2c2::Enabled
    }
}
#[doc = "Field `LPI2C2` writer - LPI2C2"]
pub type Lpi2c2W<'a, REG> = crate::BitWriter<'a, REG, Lpi2c2>;
impl<'a, REG> Lpi2c2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpi2c2::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpi2c2::Enabled)
    }
}
#[doc = "LPI2C3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Lpi2c3 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Lpi2c3> for bool {
    #[inline(always)]
    fn from(variant: Lpi2c3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `LPI2C3` reader - LPI2C3"]
pub type Lpi2c3R = crate::BitReader<Lpi2c3>;
impl Lpi2c3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Lpi2c3 {
        match self.bits {
            false => Lpi2c3::Disabled,
            true => Lpi2c3::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Lpi2c3::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Lpi2c3::Enabled
    }
}
#[doc = "Field `LPI2C3` writer - LPI2C3"]
pub type Lpi2c3W<'a, REG> = crate::BitWriter<'a, REG, Lpi2c3>;
impl<'a, REG> Lpi2c3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpi2c3::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpi2c3::Enabled)
    }
}
#[doc = "LPUART5\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Lpuart5 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Lpuart5> for bool {
    #[inline(always)]
    fn from(variant: Lpuart5) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `LPUART5` reader - LPUART5"]
pub type Lpuart5R = crate::BitReader<Lpuart5>;
impl Lpuart5R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Lpuart5 {
        match self.bits {
            false => Lpuart5::Disabled,
            true => Lpuart5::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Lpuart5::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Lpuart5::Enabled
    }
}
#[doc = "Field `LPUART5` writer - LPUART5"]
pub type Lpuart5W<'a, REG> = crate::BitWriter<'a, REG, Lpuart5>;
impl<'a, REG> Lpuart5W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpuart5::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Lpuart5::Enabled)
    }
}
#[doc = "PKC0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Pkc0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Pkc0> for bool {
    #[inline(always)]
    fn from(variant: Pkc0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `PKC0` reader - PKC0"]
pub type Pkc0R = crate::BitReader<Pkc0>;
impl Pkc0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Pkc0 {
        match self.bits {
            false => Pkc0::Disabled,
            true => Pkc0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Pkc0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Pkc0::Enabled
    }
}
#[doc = "Field `PKC0` writer - PKC0"]
pub type Pkc0W<'a, REG> = crate::BitWriter<'a, REG, Pkc0>;
impl<'a, REG> Pkc0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Pkc0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Pkc0::Enabled)
    }
}
#[doc = "TRNG0\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Trng0 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Trng0> for bool {
    #[inline(always)]
    fn from(variant: Trng0) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `TRNG0` reader - TRNG0"]
pub type Trng0R = crate::BitReader<Trng0>;
impl Trng0R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Trng0 {
        match self.bits {
            false => Trng0::Disabled,
            true => Trng0::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Trng0::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Trng0::Enabled
    }
}
#[doc = "Field `TRNG0` writer - TRNG0"]
pub type Trng0W<'a, REG> = crate::BitWriter<'a, REG, Trng0>;
impl<'a, REG> Trng0W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Trng0::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Trng0::Enabled)
    }
}
#[doc = "ADC2\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Adc2 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Adc2> for bool {
    #[inline(always)]
    fn from(variant: Adc2) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `ADC2` reader - ADC2"]
pub type Adc2R = crate::BitReader<Adc2>;
impl Adc2R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Adc2 {
        match self.bits {
            false => Adc2::Disabled,
            true => Adc2::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Adc2::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Adc2::Enabled
    }
}
#[doc = "Field `ADC2` writer - ADC2"]
pub type Adc2W<'a, REG> = crate::BitWriter<'a, REG, Adc2>;
impl<'a, REG> Adc2W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc2::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc2::Enabled)
    }
}
#[doc = "ADC3\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Adc3 {
    #[doc = "0: Peripheral is held in reset"]
    Disabled = 0,
    #[doc = "1: Peripheral is released from reset"]
    Enabled = 1,
}
impl From<Adc3> for bool {
    #[inline(always)]
    fn from(variant: Adc3) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `ADC3` reader - ADC3"]
pub type Adc3R = crate::BitReader<Adc3>;
impl Adc3R {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Adc3 {
        match self.bits {
            false => Adc3::Disabled,
            true => Adc3::Enabled,
        }
    }
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn is_disabled(&self) -> bool {
        *self == Adc3::Disabled
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn is_enabled(&self) -> bool {
        *self == Adc3::Enabled
    }
}
#[doc = "Field `ADC3` writer - ADC3"]
pub type Adc3W<'a, REG> = crate::BitWriter<'a, REG, Adc3>;
impl<'a, REG> Adc3W<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "Peripheral is held in reset"]
    #[inline(always)]
    pub fn disabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc3::Disabled)
    }
    #[doc = "Peripheral is released from reset"]
    #[inline(always)]
    pub fn enabled(self) -> &'a mut crate::W<REG> {
        self.variant(Adc3::Enabled)
    }
}
impl R {
    #[doc = "Bit 0 - FLEXPWM1"]
    #[inline(always)]
    pub fn flexpwm1(&self) -> Flexpwm1R {
        Flexpwm1R::new((self.bits & 1) != 0)
    }
    #[doc = "Bit 1 - OSTIMER0"]
    #[inline(always)]
    pub fn ostimer0(&self) -> Ostimer0R {
        Ostimer0R::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - ADC0"]
    #[inline(always)]
    pub fn adc0(&self) -> Adc0R {
        Adc0R::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - ADC1"]
    #[inline(always)]
    pub fn adc1(&self) -> Adc1R {
        Adc1R::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 5 - CMP1"]
    #[inline(always)]
    pub fn cmp1(&self) -> Cmp1R {
        Cmp1R::new(((self.bits >> 5) & 1) != 0)
    }
    #[doc = "Bit 6 - CMP2"]
    #[inline(always)]
    pub fn cmp2(&self) -> Cmp2R {
        Cmp2R::new(((self.bits >> 6) & 1) != 0)
    }
    #[doc = "Bit 7 - DAC0"]
    #[inline(always)]
    pub fn dac0(&self) -> Dac0R {
        Dac0R::new(((self.bits >> 7) & 1) != 0)
    }
    #[doc = "Bit 8 - OPAMP0"]
    #[inline(always)]
    pub fn opamp0(&self) -> Opamp0R {
        Opamp0R::new(((self.bits >> 8) & 1) != 0)
    }
    #[doc = "Bit 9 - OPAMP1"]
    #[inline(always)]
    pub fn opamp1(&self) -> Opamp1R {
        Opamp1R::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - OPAMP2"]
    #[inline(always)]
    pub fn opamp2(&self) -> Opamp2R {
        Opamp2R::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 11 - OPAMP3"]
    #[inline(always)]
    pub fn opamp3(&self) -> Opamp3R {
        Opamp3R::new(((self.bits >> 11) & 1) != 0)
    }
    #[doc = "Bit 12 - PORT0"]
    #[inline(always)]
    pub fn port0(&self) -> Port0R {
        Port0R::new(((self.bits >> 12) & 1) != 0)
    }
    #[doc = "Bit 13 - PORT1"]
    #[inline(always)]
    pub fn port1(&self) -> Port1R {
        Port1R::new(((self.bits >> 13) & 1) != 0)
    }
    #[doc = "Bit 14 - PORT2"]
    #[inline(always)]
    pub fn port2(&self) -> Port2R {
        Port2R::new(((self.bits >> 14) & 1) != 0)
    }
    #[doc = "Bit 15 - PORT3"]
    #[inline(always)]
    pub fn port3(&self) -> Port3R {
        Port3R::new(((self.bits >> 15) & 1) != 0)
    }
    #[doc = "Bit 16 - PORT4"]
    #[inline(always)]
    pub fn port4(&self) -> Port4R {
        Port4R::new(((self.bits >> 16) & 1) != 0)
    }
    #[doc = "Bit 17 - SLCD0"]
    #[inline(always)]
    pub fn slcd0(&self) -> Slcd0R {
        Slcd0R::new(((self.bits >> 17) & 1) != 0)
    }
    #[doc = "Bit 18 - FLEXCAN0"]
    #[inline(always)]
    pub fn flexcan0(&self) -> Flexcan0R {
        Flexcan0R::new(((self.bits >> 18) & 1) != 0)
    }
    #[doc = "Bit 19 - FLEXCAN1"]
    #[inline(always)]
    pub fn flexcan1(&self) -> Flexcan1R {
        Flexcan1R::new(((self.bits >> 19) & 1) != 0)
    }
    #[doc = "Bit 20 - LPI2C2"]
    #[inline(always)]
    pub fn lpi2c2(&self) -> Lpi2c2R {
        Lpi2c2R::new(((self.bits >> 20) & 1) != 0)
    }
    #[doc = "Bit 21 - LPI2C3"]
    #[inline(always)]
    pub fn lpi2c3(&self) -> Lpi2c3R {
        Lpi2c3R::new(((self.bits >> 21) & 1) != 0)
    }
    #[doc = "Bit 22 - LPUART5"]
    #[inline(always)]
    pub fn lpuart5(&self) -> Lpuart5R {
        Lpuart5R::new(((self.bits >> 22) & 1) != 0)
    }
    #[doc = "Bit 24 - PKC0"]
    #[inline(always)]
    pub fn pkc0(&self) -> Pkc0R {
        Pkc0R::new(((self.bits >> 24) & 1) != 0)
    }
    #[doc = "Bit 26 - TRNG0"]
    #[inline(always)]
    pub fn trng0(&self) -> Trng0R {
        Trng0R::new(((self.bits >> 26) & 1) != 0)
    }
    #[doc = "Bit 28 - ADC2"]
    #[inline(always)]
    pub fn adc2(&self) -> Adc2R {
        Adc2R::new(((self.bits >> 28) & 1) != 0)
    }
    #[doc = "Bit 29 - ADC3"]
    #[inline(always)]
    pub fn adc3(&self) -> Adc3R {
        Adc3R::new(((self.bits >> 29) & 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("MRCC_GLB_RST1")
            .field("flexpwm1", &self.flexpwm1())
            .field("ostimer0", &self.ostimer0())
            .field("adc0", &self.adc0())
            .field("adc1", &self.adc1())
            .field("cmp1", &self.cmp1())
            .field("cmp2", &self.cmp2())
            .field("dac0", &self.dac0())
            .field("opamp0", &self.opamp0())
            .field("opamp1", &self.opamp1())
            .field("opamp2", &self.opamp2())
            .field("opamp3", &self.opamp3())
            .field("port0", &self.port0())
            .field("port1", &self.port1())
            .field("port2", &self.port2())
            .field("port3", &self.port3())
            .field("port4", &self.port4())
            .field("slcd0", &self.slcd0())
            .field("flexcan0", &self.flexcan0())
            .field("flexcan1", &self.flexcan1())
            .field("lpi2c2", &self.lpi2c2())
            .field("lpi2c3", &self.lpi2c3())
            .field("lpuart5", &self.lpuart5())
            .field("pkc0", &self.pkc0())
            .field("trng0", &self.trng0())
            .field("adc2", &self.adc2())
            .field("adc3", &self.adc3())
            .finish()
    }
}
impl W {
    #[doc = "Bit 0 - FLEXPWM1"]
    #[inline(always)]
    pub fn flexpwm1(&mut self) -> Flexpwm1W<'_, MrccGlbRst1Spec> {
        Flexpwm1W::new(self, 0)
    }
    #[doc = "Bit 1 - OSTIMER0"]
    #[inline(always)]
    pub fn ostimer0(&mut self) -> Ostimer0W<'_, MrccGlbRst1Spec> {
        Ostimer0W::new(self, 1)
    }
    #[doc = "Bit 2 - ADC0"]
    #[inline(always)]
    pub fn adc0(&mut self) -> Adc0W<'_, MrccGlbRst1Spec> {
        Adc0W::new(self, 2)
    }
    #[doc = "Bit 3 - ADC1"]
    #[inline(always)]
    pub fn adc1(&mut self) -> Adc1W<'_, MrccGlbRst1Spec> {
        Adc1W::new(self, 3)
    }
    #[doc = "Bit 5 - CMP1"]
    #[inline(always)]
    pub fn cmp1(&mut self) -> Cmp1W<'_, MrccGlbRst1Spec> {
        Cmp1W::new(self, 5)
    }
    #[doc = "Bit 6 - CMP2"]
    #[inline(always)]
    pub fn cmp2(&mut self) -> Cmp2W<'_, MrccGlbRst1Spec> {
        Cmp2W::new(self, 6)
    }
    #[doc = "Bit 7 - DAC0"]
    #[inline(always)]
    pub fn dac0(&mut self) -> Dac0W<'_, MrccGlbRst1Spec> {
        Dac0W::new(self, 7)
    }
    #[doc = "Bit 8 - OPAMP0"]
    #[inline(always)]
    pub fn opamp0(&mut self) -> Opamp0W<'_, MrccGlbRst1Spec> {
        Opamp0W::new(self, 8)
    }
    #[doc = "Bit 9 - OPAMP1"]
    #[inline(always)]
    pub fn opamp1(&mut self) -> Opamp1W<'_, MrccGlbRst1Spec> {
        Opamp1W::new(self, 9)
    }
    #[doc = "Bit 10 - OPAMP2"]
    #[inline(always)]
    pub fn opamp2(&mut self) -> Opamp2W<'_, MrccGlbRst1Spec> {
        Opamp2W::new(self, 10)
    }
    #[doc = "Bit 11 - OPAMP3"]
    #[inline(always)]
    pub fn opamp3(&mut self) -> Opamp3W<'_, MrccGlbRst1Spec> {
        Opamp3W::new(self, 11)
    }
    #[doc = "Bit 12 - PORT0"]
    #[inline(always)]
    pub fn port0(&mut self) -> Port0W<'_, MrccGlbRst1Spec> {
        Port0W::new(self, 12)
    }
    #[doc = "Bit 13 - PORT1"]
    #[inline(always)]
    pub fn port1(&mut self) -> Port1W<'_, MrccGlbRst1Spec> {
        Port1W::new(self, 13)
    }
    #[doc = "Bit 14 - PORT2"]
    #[inline(always)]
    pub fn port2(&mut self) -> Port2W<'_, MrccGlbRst1Spec> {
        Port2W::new(self, 14)
    }
    #[doc = "Bit 15 - PORT3"]
    #[inline(always)]
    pub fn port3(&mut self) -> Port3W<'_, MrccGlbRst1Spec> {
        Port3W::new(self, 15)
    }
    #[doc = "Bit 16 - PORT4"]
    #[inline(always)]
    pub fn port4(&mut self) -> Port4W<'_, MrccGlbRst1Spec> {
        Port4W::new(self, 16)
    }
    #[doc = "Bit 17 - SLCD0"]
    #[inline(always)]
    pub fn slcd0(&mut self) -> Slcd0W<'_, MrccGlbRst1Spec> {
        Slcd0W::new(self, 17)
    }
    #[doc = "Bit 18 - FLEXCAN0"]
    #[inline(always)]
    pub fn flexcan0(&mut self) -> Flexcan0W<'_, MrccGlbRst1Spec> {
        Flexcan0W::new(self, 18)
    }
    #[doc = "Bit 19 - FLEXCAN1"]
    #[inline(always)]
    pub fn flexcan1(&mut self) -> Flexcan1W<'_, MrccGlbRst1Spec> {
        Flexcan1W::new(self, 19)
    }
    #[doc = "Bit 20 - LPI2C2"]
    #[inline(always)]
    pub fn lpi2c2(&mut self) -> Lpi2c2W<'_, MrccGlbRst1Spec> {
        Lpi2c2W::new(self, 20)
    }
    #[doc = "Bit 21 - LPI2C3"]
    #[inline(always)]
    pub fn lpi2c3(&mut self) -> Lpi2c3W<'_, MrccGlbRst1Spec> {
        Lpi2c3W::new(self, 21)
    }
    #[doc = "Bit 22 - LPUART5"]
    #[inline(always)]
    pub fn lpuart5(&mut self) -> Lpuart5W<'_, MrccGlbRst1Spec> {
        Lpuart5W::new(self, 22)
    }
    #[doc = "Bit 24 - PKC0"]
    #[inline(always)]
    pub fn pkc0(&mut self) -> Pkc0W<'_, MrccGlbRst1Spec> {
        Pkc0W::new(self, 24)
    }
    #[doc = "Bit 26 - TRNG0"]
    #[inline(always)]
    pub fn trng0(&mut self) -> Trng0W<'_, MrccGlbRst1Spec> {
        Trng0W::new(self, 26)
    }
    #[doc = "Bit 28 - ADC2"]
    #[inline(always)]
    pub fn adc2(&mut self) -> Adc2W<'_, MrccGlbRst1Spec> {
        Adc2W::new(self, 28)
    }
    #[doc = "Bit 29 - ADC3"]
    #[inline(always)]
    pub fn adc3(&mut self) -> Adc3W<'_, MrccGlbRst1Spec> {
        Adc3W::new(self, 29)
    }
}
#[doc = "Peripheral Reset Control 1\n\nYou can [`read`](crate::Reg::read) this register and get [`mrcc_glb_rst1::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`mrcc_glb_rst1::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct MrccGlbRst1Spec;
impl crate::RegisterSpec for MrccGlbRst1Spec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`mrcc_glb_rst1::R`](R) reader structure"]
impl crate::Readable for MrccGlbRst1Spec {}
#[doc = "`write(|w| ..)` method takes [`mrcc_glb_rst1::W`](W) writer structure"]
impl crate::Writable for MrccGlbRst1Spec {
    type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets MRCC_GLB_RST1 to value 0"]
impl crate::Resettable for MrccGlbRst1Spec {}
