#[doc = r" Value read from the register"]
pub struct R {
    bits: u32,
}
impl super::CSSTAT {
    #[doc = r" Reads the contents of the register"]
    #[inline]
    pub fn read(&self) -> R {
        R {
            bits: self.register.get(),
        }
    }
}
#[doc = "Possible values of the field `DCO_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DCO_ONR {
    #[doc = "Inactive"]
    DCO_ON_0,
    #[doc = "Active"]
    DCO_ON_1,
}
impl DCO_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            DCO_ONR::DCO_ON_0 => false,
            DCO_ONR::DCO_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> DCO_ONR {
        match value {
            false => DCO_ONR::DCO_ON_0,
            true => DCO_ONR::DCO_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `DCO_ON_0`"]
    #[inline]
    pub fn is_dco_on_0(&self) -> bool {
        *self == DCO_ONR::DCO_ON_0
    }
    #[doc = "Checks if the value of the field is `DCO_ON_1`"]
    #[inline]
    pub fn is_dco_on_1(&self) -> bool {
        *self == DCO_ONR::DCO_ON_1
    }
}
#[doc = "Possible values of the field `DCOBIAS_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DCOBIAS_ONR {
    #[doc = "Inactive"]
    DCOBIAS_ON_0,
    #[doc = "Active"]
    DCOBIAS_ON_1,
}
impl DCOBIAS_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            DCOBIAS_ONR::DCOBIAS_ON_0 => false,
            DCOBIAS_ONR::DCOBIAS_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> DCOBIAS_ONR {
        match value {
            false => DCOBIAS_ONR::DCOBIAS_ON_0,
            true => DCOBIAS_ONR::DCOBIAS_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `DCOBIAS_ON_0`"]
    #[inline]
    pub fn is_dcobias_on_0(&self) -> bool {
        *self == DCOBIAS_ONR::DCOBIAS_ON_0
    }
    #[doc = "Checks if the value of the field is `DCOBIAS_ON_1`"]
    #[inline]
    pub fn is_dcobias_on_1(&self) -> bool {
        *self == DCOBIAS_ONR::DCOBIAS_ON_1
    }
}
#[doc = "Possible values of the field `HFXT_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXT_ONR {
    #[doc = "Inactive"]
    HFXT_ON_0,
    #[doc = "Active"]
    HFXT_ON_1,
}
impl HFXT_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            HFXT_ONR::HFXT_ON_0 => false,
            HFXT_ONR::HFXT_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXT_ONR {
        match value {
            false => HFXT_ONR::HFXT_ON_0,
            true => HFXT_ONR::HFXT_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXT_ON_0`"]
    #[inline]
    pub fn is_hfxt_on_0(&self) -> bool {
        *self == HFXT_ONR::HFXT_ON_0
    }
    #[doc = "Checks if the value of the field is `HFXT_ON_1`"]
    #[inline]
    pub fn is_hfxt_on_1(&self) -> bool {
        *self == HFXT_ONR::HFXT_ON_1
    }
}
#[doc = "Possible values of the field `HFXT2_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXT2_ONR {
    #[doc = "Inactive"]
    HFXT2_ON_0,
    #[doc = "Active"]
    HFXT2_ON_1,
}
impl HFXT2_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            HFXT2_ONR::HFXT2_ON_0 => false,
            HFXT2_ONR::HFXT2_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXT2_ONR {
        match value {
            false => HFXT2_ONR::HFXT2_ON_0,
            true => HFXT2_ONR::HFXT2_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXT2_ON_0`"]
    #[inline]
    pub fn is_hfxt2_on_0(&self) -> bool {
        *self == HFXT2_ONR::HFXT2_ON_0
    }
    #[doc = "Checks if the value of the field is `HFXT2_ON_1`"]
    #[inline]
    pub fn is_hfxt2_on_1(&self) -> bool {
        *self == HFXT2_ONR::HFXT2_ON_1
    }
}
#[doc = "Possible values of the field `MODOSC_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MODOSC_ONR {
    #[doc = "Inactive"]
    MODOSC_ON_0,
    #[doc = "Active"]
    MODOSC_ON_1,
}
impl MODOSC_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            MODOSC_ONR::MODOSC_ON_0 => false,
            MODOSC_ONR::MODOSC_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> MODOSC_ONR {
        match value {
            false => MODOSC_ONR::MODOSC_ON_0,
            true => MODOSC_ONR::MODOSC_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `MODOSC_ON_0`"]
    #[inline]
    pub fn is_modosc_on_0(&self) -> bool {
        *self == MODOSC_ONR::MODOSC_ON_0
    }
    #[doc = "Checks if the value of the field is `MODOSC_ON_1`"]
    #[inline]
    pub fn is_modosc_on_1(&self) -> bool {
        *self == MODOSC_ONR::MODOSC_ON_1
    }
}
#[doc = "Possible values of the field `VLO_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum VLO_ONR {
    #[doc = "Inactive"]
    VLO_ON_0,
    #[doc = "Active"]
    VLO_ON_1,
}
impl VLO_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            VLO_ONR::VLO_ON_0 => false,
            VLO_ONR::VLO_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> VLO_ONR {
        match value {
            false => VLO_ONR::VLO_ON_0,
            true => VLO_ONR::VLO_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `VLO_ON_0`"]
    #[inline]
    pub fn is_vlo_on_0(&self) -> bool {
        *self == VLO_ONR::VLO_ON_0
    }
    #[doc = "Checks if the value of the field is `VLO_ON_1`"]
    #[inline]
    pub fn is_vlo_on_1(&self) -> bool {
        *self == VLO_ONR::VLO_ON_1
    }
}
#[doc = "Possible values of the field `LFXT_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXT_ONR {
    #[doc = "Inactive"]
    LFXT_ON_0,
    #[doc = "Active"]
    LFXT_ON_1,
}
impl LFXT_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            LFXT_ONR::LFXT_ON_0 => false,
            LFXT_ONR::LFXT_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXT_ONR {
        match value {
            false => LFXT_ONR::LFXT_ON_0,
            true => LFXT_ONR::LFXT_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXT_ON_0`"]
    #[inline]
    pub fn is_lfxt_on_0(&self) -> bool {
        *self == LFXT_ONR::LFXT_ON_0
    }
    #[doc = "Checks if the value of the field is `LFXT_ON_1`"]
    #[inline]
    pub fn is_lfxt_on_1(&self) -> bool {
        *self == LFXT_ONR::LFXT_ON_1
    }
}
#[doc = "Possible values of the field `REFO_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum REFO_ONR {
    #[doc = "Inactive"]
    REFO_ON_0,
    #[doc = "Active"]
    REFO_ON_1,
}
impl REFO_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            REFO_ONR::REFO_ON_0 => false,
            REFO_ONR::REFO_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> REFO_ONR {
        match value {
            false => REFO_ONR::REFO_ON_0,
            true => REFO_ONR::REFO_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `REFO_ON_0`"]
    #[inline]
    pub fn is_refo_on_0(&self) -> bool {
        *self == REFO_ONR::REFO_ON_0
    }
    #[doc = "Checks if the value of the field is `REFO_ON_1`"]
    #[inline]
    pub fn is_refo_on_1(&self) -> bool {
        *self == REFO_ONR::REFO_ON_1
    }
}
#[doc = "Possible values of the field `ACLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ACLK_ONR {
    #[doc = "Inactive"]
    ACLK_ON_0,
    #[doc = "Active"]
    ACLK_ON_1,
}
impl ACLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ACLK_ONR::ACLK_ON_0 => false,
            ACLK_ONR::ACLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ACLK_ONR {
        match value {
            false => ACLK_ONR::ACLK_ON_0,
            true => ACLK_ONR::ACLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `ACLK_ON_0`"]
    #[inline]
    pub fn is_aclk_on_0(&self) -> bool {
        *self == ACLK_ONR::ACLK_ON_0
    }
    #[doc = "Checks if the value of the field is `ACLK_ON_1`"]
    #[inline]
    pub fn is_aclk_on_1(&self) -> bool {
        *self == ACLK_ONR::ACLK_ON_1
    }
}
#[doc = "Possible values of the field `MCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MCLK_ONR {
    #[doc = "Inactive"]
    MCLK_ON_0,
    #[doc = "Active"]
    MCLK_ON_1,
}
impl MCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            MCLK_ONR::MCLK_ON_0 => false,
            MCLK_ONR::MCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> MCLK_ONR {
        match value {
            false => MCLK_ONR::MCLK_ON_0,
            true => MCLK_ONR::MCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `MCLK_ON_0`"]
    #[inline]
    pub fn is_mclk_on_0(&self) -> bool {
        *self == MCLK_ONR::MCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `MCLK_ON_1`"]
    #[inline]
    pub fn is_mclk_on_1(&self) -> bool {
        *self == MCLK_ONR::MCLK_ON_1
    }
}
#[doc = "Possible values of the field `HSMCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSMCLK_ONR {
    #[doc = "Inactive"]
    HSMCLK_ON_0,
    #[doc = "Active"]
    HSMCLK_ON_1,
}
impl HSMCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            HSMCLK_ONR::HSMCLK_ON_0 => false,
            HSMCLK_ONR::HSMCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HSMCLK_ONR {
        match value {
            false => HSMCLK_ONR::HSMCLK_ON_0,
            true => HSMCLK_ONR::HSMCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `HSMCLK_ON_0`"]
    #[inline]
    pub fn is_hsmclk_on_0(&self) -> bool {
        *self == HSMCLK_ONR::HSMCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `HSMCLK_ON_1`"]
    #[inline]
    pub fn is_hsmclk_on_1(&self) -> bool {
        *self == HSMCLK_ONR::HSMCLK_ON_1
    }
}
#[doc = "Possible values of the field `SMCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SMCLK_ONR {
    #[doc = "Inactive"]
    SMCLK_ON_0,
    #[doc = "Active"]
    SMCLK_ON_1,
}
impl SMCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            SMCLK_ONR::SMCLK_ON_0 => false,
            SMCLK_ONR::SMCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> SMCLK_ONR {
        match value {
            false => SMCLK_ONR::SMCLK_ON_0,
            true => SMCLK_ONR::SMCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `SMCLK_ON_0`"]
    #[inline]
    pub fn is_smclk_on_0(&self) -> bool {
        *self == SMCLK_ONR::SMCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `SMCLK_ON_1`"]
    #[inline]
    pub fn is_smclk_on_1(&self) -> bool {
        *self == SMCLK_ONR::SMCLK_ON_1
    }
}
#[doc = "Possible values of the field `MODCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MODCLK_ONR {
    #[doc = "Inactive"]
    MODCLK_ON_0,
    #[doc = "Active"]
    MODCLK_ON_1,
}
impl MODCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            MODCLK_ONR::MODCLK_ON_0 => false,
            MODCLK_ONR::MODCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> MODCLK_ONR {
        match value {
            false => MODCLK_ONR::MODCLK_ON_0,
            true => MODCLK_ONR::MODCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `MODCLK_ON_0`"]
    #[inline]
    pub fn is_modclk_on_0(&self) -> bool {
        *self == MODCLK_ONR::MODCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `MODCLK_ON_1`"]
    #[inline]
    pub fn is_modclk_on_1(&self) -> bool {
        *self == MODCLK_ONR::MODCLK_ON_1
    }
}
#[doc = "Possible values of the field `VLOCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum VLOCLK_ONR {
    #[doc = "Inactive"]
    VLOCLK_ON_0,
    #[doc = "Active"]
    VLOCLK_ON_1,
}
impl VLOCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            VLOCLK_ONR::VLOCLK_ON_0 => false,
            VLOCLK_ONR::VLOCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> VLOCLK_ONR {
        match value {
            false => VLOCLK_ONR::VLOCLK_ON_0,
            true => VLOCLK_ONR::VLOCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `VLOCLK_ON_0`"]
    #[inline]
    pub fn is_vloclk_on_0(&self) -> bool {
        *self == VLOCLK_ONR::VLOCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `VLOCLK_ON_1`"]
    #[inline]
    pub fn is_vloclk_on_1(&self) -> bool {
        *self == VLOCLK_ONR::VLOCLK_ON_1
    }
}
#[doc = "Possible values of the field `LFXTCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXTCLK_ONR {
    #[doc = "Inactive"]
    LFXTCLK_ON_0,
    #[doc = "Active"]
    LFXTCLK_ON_1,
}
impl LFXTCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            LFXTCLK_ONR::LFXTCLK_ON_0 => false,
            LFXTCLK_ONR::LFXTCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXTCLK_ONR {
        match value {
            false => LFXTCLK_ONR::LFXTCLK_ON_0,
            true => LFXTCLK_ONR::LFXTCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXTCLK_ON_0`"]
    #[inline]
    pub fn is_lfxtclk_on_0(&self) -> bool {
        *self == LFXTCLK_ONR::LFXTCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `LFXTCLK_ON_1`"]
    #[inline]
    pub fn is_lfxtclk_on_1(&self) -> bool {
        *self == LFXTCLK_ONR::LFXTCLK_ON_1
    }
}
#[doc = "Possible values of the field `REFOCLK_ON`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum REFOCLK_ONR {
    #[doc = "Inactive"]
    REFOCLK_ON_0,
    #[doc = "Active"]
    REFOCLK_ON_1,
}
impl REFOCLK_ONR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            REFOCLK_ONR::REFOCLK_ON_0 => false,
            REFOCLK_ONR::REFOCLK_ON_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> REFOCLK_ONR {
        match value {
            false => REFOCLK_ONR::REFOCLK_ON_0,
            true => REFOCLK_ONR::REFOCLK_ON_1,
        }
    }
    #[doc = "Checks if the value of the field is `REFOCLK_ON_0`"]
    #[inline]
    pub fn is_refoclk_on_0(&self) -> bool {
        *self == REFOCLK_ONR::REFOCLK_ON_0
    }
    #[doc = "Checks if the value of the field is `REFOCLK_ON_1`"]
    #[inline]
    pub fn is_refoclk_on_1(&self) -> bool {
        *self == REFOCLK_ONR::REFOCLK_ON_1
    }
}
#[doc = "Possible values of the field `ACLK_READY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ACLK_READYR {
    #[doc = "Not ready"]
    ACLK_READY_0,
    #[doc = "Ready"]
    ACLK_READY_1,
}
impl ACLK_READYR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            ACLK_READYR::ACLK_READY_0 => false,
            ACLK_READYR::ACLK_READY_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> ACLK_READYR {
        match value {
            false => ACLK_READYR::ACLK_READY_0,
            true => ACLK_READYR::ACLK_READY_1,
        }
    }
    #[doc = "Checks if the value of the field is `ACLK_READY_0`"]
    #[inline]
    pub fn is_aclk_ready_0(&self) -> bool {
        *self == ACLK_READYR::ACLK_READY_0
    }
    #[doc = "Checks if the value of the field is `ACLK_READY_1`"]
    #[inline]
    pub fn is_aclk_ready_1(&self) -> bool {
        *self == ACLK_READYR::ACLK_READY_1
    }
}
#[doc = "Possible values of the field `MCLK_READY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MCLK_READYR {
    #[doc = "Not ready"]
    MCLK_READY_0,
    #[doc = "Ready"]
    MCLK_READY_1,
}
impl MCLK_READYR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            MCLK_READYR::MCLK_READY_0 => false,
            MCLK_READYR::MCLK_READY_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> MCLK_READYR {
        match value {
            false => MCLK_READYR::MCLK_READY_0,
            true => MCLK_READYR::MCLK_READY_1,
        }
    }
    #[doc = "Checks if the value of the field is `MCLK_READY_0`"]
    #[inline]
    pub fn is_mclk_ready_0(&self) -> bool {
        *self == MCLK_READYR::MCLK_READY_0
    }
    #[doc = "Checks if the value of the field is `MCLK_READY_1`"]
    #[inline]
    pub fn is_mclk_ready_1(&self) -> bool {
        *self == MCLK_READYR::MCLK_READY_1
    }
}
#[doc = "Possible values of the field `HSMCLK_READY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSMCLK_READYR {
    #[doc = "Not ready"]
    HSMCLK_READY_0,
    #[doc = "Ready"]
    HSMCLK_READY_1,
}
impl HSMCLK_READYR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            HSMCLK_READYR::HSMCLK_READY_0 => false,
            HSMCLK_READYR::HSMCLK_READY_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HSMCLK_READYR {
        match value {
            false => HSMCLK_READYR::HSMCLK_READY_0,
            true => HSMCLK_READYR::HSMCLK_READY_1,
        }
    }
    #[doc = "Checks if the value of the field is `HSMCLK_READY_0`"]
    #[inline]
    pub fn is_hsmclk_ready_0(&self) -> bool {
        *self == HSMCLK_READYR::HSMCLK_READY_0
    }
    #[doc = "Checks if the value of the field is `HSMCLK_READY_1`"]
    #[inline]
    pub fn is_hsmclk_ready_1(&self) -> bool {
        *self == HSMCLK_READYR::HSMCLK_READY_1
    }
}
#[doc = "Possible values of the field `SMCLK_READY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SMCLK_READYR {
    #[doc = "Not ready"]
    SMCLK_READY_0,
    #[doc = "Ready"]
    SMCLK_READY_1,
}
impl SMCLK_READYR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            SMCLK_READYR::SMCLK_READY_0 => false,
            SMCLK_READYR::SMCLK_READY_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> SMCLK_READYR {
        match value {
            false => SMCLK_READYR::SMCLK_READY_0,
            true => SMCLK_READYR::SMCLK_READY_1,
        }
    }
    #[doc = "Checks if the value of the field is `SMCLK_READY_0`"]
    #[inline]
    pub fn is_smclk_ready_0(&self) -> bool {
        *self == SMCLK_READYR::SMCLK_READY_0
    }
    #[doc = "Checks if the value of the field is `SMCLK_READY_1`"]
    #[inline]
    pub fn is_smclk_ready_1(&self) -> bool {
        *self == SMCLK_READYR::SMCLK_READY_1
    }
}
#[doc = "Possible values of the field `BCLK_READY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BCLK_READYR {
    #[doc = "Not ready"]
    BCLK_READY_0,
    #[doc = "Ready"]
    BCLK_READY_1,
}
impl BCLK_READYR {
    #[doc = r" Returns `true` if the bit is clear (0)"]
    #[inline]
    pub fn bit_is_clear(&self) -> bool {
        !self.bit()
    }
    #[doc = r" Returns `true` if the bit is set (1)"]
    #[inline]
    pub fn bit_is_set(&self) -> bool {
        self.bit()
    }
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bit(&self) -> bool {
        match *self {
            BCLK_READYR::BCLK_READY_0 => false,
            BCLK_READYR::BCLK_READY_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> BCLK_READYR {
        match value {
            false => BCLK_READYR::BCLK_READY_0,
            true => BCLK_READYR::BCLK_READY_1,
        }
    }
    #[doc = "Checks if the value of the field is `BCLK_READY_0`"]
    #[inline]
    pub fn is_bclk_ready_0(&self) -> bool {
        *self == BCLK_READYR::BCLK_READY_0
    }
    #[doc = "Checks if the value of the field is `BCLK_READY_1`"]
    #[inline]
    pub fn is_bclk_ready_1(&self) -> bool {
        *self == BCLK_READYR::BCLK_READY_1
    }
}
impl R {
    #[doc = r" Value of the register as raw bits"]
    #[inline]
    pub fn bits(&self) -> u32 {
        self.bits
    }
    #[doc = "Bit 0 - DCO status"]
    #[inline]
    pub fn dco_on(&self) -> DCO_ONR {
        DCO_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 1 - DCO bias status"]
    #[inline]
    pub fn dcobias_on(&self) -> DCOBIAS_ONR {
        DCOBIAS_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 1;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 2 - HFXT status"]
    #[inline]
    pub fn hfxt_on(&self) -> HFXT_ONR {
        HFXT_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 2;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 3 - HFXT2 status"]
    #[inline]
    pub fn hfxt2_on(&self) -> HFXT2_ONR {
        HFXT2_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 3;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 4 - MODOSC status"]
    #[inline]
    pub fn modosc_on(&self) -> MODOSC_ONR {
        MODOSC_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 4;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 5 - VLO status"]
    #[inline]
    pub fn vlo_on(&self) -> VLO_ONR {
        VLO_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 5;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 6 - LFXT status"]
    #[inline]
    pub fn lfxt_on(&self) -> LFXT_ONR {
        LFXT_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 6;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 7 - REFO status"]
    #[inline]
    pub fn refo_on(&self) -> REFO_ONR {
        REFO_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 7;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 16 - ACLK system clock status"]
    #[inline]
    pub fn aclk_on(&self) -> ACLK_ONR {
        ACLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 16;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 17 - MCLK system clock status"]
    #[inline]
    pub fn mclk_on(&self) -> MCLK_ONR {
        MCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 17;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 18 - HSMCLK system clock status"]
    #[inline]
    pub fn hsmclk_on(&self) -> HSMCLK_ONR {
        HSMCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 18;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 19 - SMCLK system clock status"]
    #[inline]
    pub fn smclk_on(&self) -> SMCLK_ONR {
        SMCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 19;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 20 - MODCLK system clock status"]
    #[inline]
    pub fn modclk_on(&self) -> MODCLK_ONR {
        MODCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 20;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 21 - VLOCLK system clock status"]
    #[inline]
    pub fn vloclk_on(&self) -> VLOCLK_ONR {
        VLOCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 21;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 22 - LFXTCLK system clock status"]
    #[inline]
    pub fn lfxtclk_on(&self) -> LFXTCLK_ONR {
        LFXTCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 22;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 23 - REFOCLK system clock status"]
    #[inline]
    pub fn refoclk_on(&self) -> REFOCLK_ONR {
        REFOCLK_ONR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 23;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 24 - ACLK Ready status"]
    #[inline]
    pub fn aclk_ready(&self) -> ACLK_READYR {
        ACLK_READYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 24;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 25 - MCLK Ready status"]
    #[inline]
    pub fn mclk_ready(&self) -> MCLK_READYR {
        MCLK_READYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 25;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 26 - HSMCLK Ready status"]
    #[inline]
    pub fn hsmclk_ready(&self) -> HSMCLK_READYR {
        HSMCLK_READYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 26;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 27 - SMCLK Ready status"]
    #[inline]
    pub fn smclk_ready(&self) -> SMCLK_READYR {
        SMCLK_READYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 27;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 28 - BCLK Ready status"]
    #[inline]
    pub fn bclk_ready(&self) -> BCLK_READYR {
        BCLK_READYR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 28;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
}