#[doc = r" Value read from the register"]
pub struct R {
    bits: u32,
}
impl super::CSIFG {
    #[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 `LFXTIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXTIFGR {
    #[doc = "No fault condition occurred after the last reset"]
    LFXTIFG_0,
    #[doc = "LFXT fault. A LFXT fault occurred after the last reset"]
    LFXTIFG_1,
}
impl LFXTIFGR {
    #[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 {
            LFXTIFGR::LFXTIFG_0 => false,
            LFXTIFGR::LFXTIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXTIFGR {
        match value {
            false => LFXTIFGR::LFXTIFG_0,
            true => LFXTIFGR::LFXTIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXTIFG_0`"]
    #[inline]
    pub fn is_lfxtifg_0(&self) -> bool {
        *self == LFXTIFGR::LFXTIFG_0
    }
    #[doc = "Checks if the value of the field is `LFXTIFG_1`"]
    #[inline]
    pub fn is_lfxtifg_1(&self) -> bool {
        *self == LFXTIFGR::LFXTIFG_1
    }
}
#[doc = "Possible values of the field `HFXTIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXTIFGR {
    #[doc = "No fault condition occurred after the last reset"]
    HFXTIFG_0,
    #[doc = "HFXT fault. A HFXT fault occurred after the last reset"]
    HFXTIFG_1,
}
impl HFXTIFGR {
    #[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 {
            HFXTIFGR::HFXTIFG_0 => false,
            HFXTIFGR::HFXTIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXTIFGR {
        match value {
            false => HFXTIFGR::HFXTIFG_0,
            true => HFXTIFGR::HFXTIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXTIFG_0`"]
    #[inline]
    pub fn is_hfxtifg_0(&self) -> bool {
        *self == HFXTIFGR::HFXTIFG_0
    }
    #[doc = "Checks if the value of the field is `HFXTIFG_1`"]
    #[inline]
    pub fn is_hfxtifg_1(&self) -> bool {
        *self == HFXTIFGR::HFXTIFG_1
    }
}
#[doc = "Possible values of the field `HFXT2IFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXT2IFGR {
    #[doc = "No fault condition occurred after the last reset"]
    HFXT2IFG_0,
    #[doc = "HFXT2 fault. A HFXT2 fault occurred after the last reset"]
    HFXT2IFG_1,
}
impl HFXT2IFGR {
    #[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 {
            HFXT2IFGR::HFXT2IFG_0 => false,
            HFXT2IFGR::HFXT2IFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXT2IFGR {
        match value {
            false => HFXT2IFGR::HFXT2IFG_0,
            true => HFXT2IFGR::HFXT2IFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXT2IFG_0`"]
    #[inline]
    pub fn is_hfxt2ifg_0(&self) -> bool {
        *self == HFXT2IFGR::HFXT2IFG_0
    }
    #[doc = "Checks if the value of the field is `HFXT2IFG_1`"]
    #[inline]
    pub fn is_hfxt2ifg_1(&self) -> bool {
        *self == HFXT2IFGR::HFXT2IFG_1
    }
}
#[doc = "Possible values of the field `DCOR_SHTIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DCOR_SHTIFGR {
    #[doc = "DCO external resistor present"]
    DCOR_SHTIFG_0,
    #[doc = "DCO external resistor short circuit fault"]
    DCOR_SHTIFG_1,
}
impl DCOR_SHTIFGR {
    #[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 {
            DCOR_SHTIFGR::DCOR_SHTIFG_0 => false,
            DCOR_SHTIFGR::DCOR_SHTIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> DCOR_SHTIFGR {
        match value {
            false => DCOR_SHTIFGR::DCOR_SHTIFG_0,
            true => DCOR_SHTIFGR::DCOR_SHTIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `DCOR_SHTIFG_0`"]
    #[inline]
    pub fn is_dcor_shtifg_0(&self) -> bool {
        *self == DCOR_SHTIFGR::DCOR_SHTIFG_0
    }
    #[doc = "Checks if the value of the field is `DCOR_SHTIFG_1`"]
    #[inline]
    pub fn is_dcor_shtifg_1(&self) -> bool {
        *self == DCOR_SHTIFGR::DCOR_SHTIFG_1
    }
}
#[doc = "Possible values of the field `DCOR_OPNIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DCOR_OPNIFGR {
    #[doc = "DCO external resistor present"]
    DCOR_OPNIFG_0,
    #[doc = "DCO external resistor open circuit fault"]
    DCOR_OPNIFG_1,
}
impl DCOR_OPNIFGR {
    #[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 {
            DCOR_OPNIFGR::DCOR_OPNIFG_0 => false,
            DCOR_OPNIFGR::DCOR_OPNIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> DCOR_OPNIFGR {
        match value {
            false => DCOR_OPNIFGR::DCOR_OPNIFG_0,
            true => DCOR_OPNIFGR::DCOR_OPNIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `DCOR_OPNIFG_0`"]
    #[inline]
    pub fn is_dcor_opnifg_0(&self) -> bool {
        *self == DCOR_OPNIFGR::DCOR_OPNIFG_0
    }
    #[doc = "Checks if the value of the field is `DCOR_OPNIFG_1`"]
    #[inline]
    pub fn is_dcor_opnifg_1(&self) -> bool {
        *self == DCOR_OPNIFGR::DCOR_OPNIFG_1
    }
}
#[doc = "Possible values of the field `FCNTLFIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FCNTLFIFGR {
    #[doc = "Start counter not expired"]
    FCNTLFIFG_0,
    #[doc = "Start counter expired"]
    FCNTLFIFG_1,
}
impl FCNTLFIFGR {
    #[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 {
            FCNTLFIFGR::FCNTLFIFG_0 => false,
            FCNTLFIFGR::FCNTLFIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> FCNTLFIFGR {
        match value {
            false => FCNTLFIFGR::FCNTLFIFG_0,
            true => FCNTLFIFGR::FCNTLFIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `FCNTLFIFG_0`"]
    #[inline]
    pub fn is_fcntlfifg_0(&self) -> bool {
        *self == FCNTLFIFGR::FCNTLFIFG_0
    }
    #[doc = "Checks if the value of the field is `FCNTLFIFG_1`"]
    #[inline]
    pub fn is_fcntlfifg_1(&self) -> bool {
        *self == FCNTLFIFGR::FCNTLFIFG_1
    }
}
#[doc = "Possible values of the field `FCNTHFIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FCNTHFIFGR {
    #[doc = "Start counter not expired"]
    FCNTHFIFG_0,
    #[doc = "Start counter expired"]
    FCNTHFIFG_1,
}
impl FCNTHFIFGR {
    #[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 {
            FCNTHFIFGR::FCNTHFIFG_0 => false,
            FCNTHFIFGR::FCNTHFIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> FCNTHFIFGR {
        match value {
            false => FCNTHFIFGR::FCNTHFIFG_0,
            true => FCNTHFIFGR::FCNTHFIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `FCNTHFIFG_0`"]
    #[inline]
    pub fn is_fcnthfifg_0(&self) -> bool {
        *self == FCNTHFIFGR::FCNTHFIFG_0
    }
    #[doc = "Checks if the value of the field is `FCNTHFIFG_1`"]
    #[inline]
    pub fn is_fcnthfifg_1(&self) -> bool {
        *self == FCNTHFIFGR::FCNTHFIFG_1
    }
}
#[doc = "Possible values of the field `FCNTHF2IFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FCNTHF2IFGR {
    #[doc = "Start counter not expired"]
    FCNTHF2IFG_0,
    #[doc = "Start counter expired"]
    FCNTHF2IFG_1,
}
impl FCNTHF2IFGR {
    #[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 {
            FCNTHF2IFGR::FCNTHF2IFG_0 => false,
            FCNTHF2IFGR::FCNTHF2IFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> FCNTHF2IFGR {
        match value {
            false => FCNTHF2IFGR::FCNTHF2IFG_0,
            true => FCNTHF2IFGR::FCNTHF2IFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `FCNTHF2IFG_0`"]
    #[inline]
    pub fn is_fcnthf2ifg_0(&self) -> bool {
        *self == FCNTHF2IFGR::FCNTHF2IFG_0
    }
    #[doc = "Checks if the value of the field is `FCNTHF2IFG_1`"]
    #[inline]
    pub fn is_fcnthf2ifg_1(&self) -> bool {
        *self == FCNTHF2IFGR::FCNTHF2IFG_1
    }
}
#[doc = "Possible values of the field `PLLOOLIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PLLOOLIFGR {
    #[doc = "No interrupt pending"]
    PLLOOLIFG_0,
    #[doc = "Interrupt pending"]
    PLLOOLIFG_1,
}
impl PLLOOLIFGR {
    #[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 {
            PLLOOLIFGR::PLLOOLIFG_0 => false,
            PLLOOLIFGR::PLLOOLIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> PLLOOLIFGR {
        match value {
            false => PLLOOLIFGR::PLLOOLIFG_0,
            true => PLLOOLIFGR::PLLOOLIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `PLLOOLIFG_0`"]
    #[inline]
    pub fn is_plloolifg_0(&self) -> bool {
        *self == PLLOOLIFGR::PLLOOLIFG_0
    }
    #[doc = "Checks if the value of the field is `PLLOOLIFG_1`"]
    #[inline]
    pub fn is_plloolifg_1(&self) -> bool {
        *self == PLLOOLIFGR::PLLOOLIFG_1
    }
}
#[doc = "Possible values of the field `PLLLOSIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PLLLOSIFGR {
    #[doc = "No interrupt pending"]
    PLLLOSIFG_0,
    #[doc = "Interrupt pending"]
    PLLLOSIFG_1,
}
impl PLLLOSIFGR {
    #[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 {
            PLLLOSIFGR::PLLLOSIFG_0 => false,
            PLLLOSIFGR::PLLLOSIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> PLLLOSIFGR {
        match value {
            false => PLLLOSIFGR::PLLLOSIFG_0,
            true => PLLLOSIFGR::PLLLOSIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `PLLLOSIFG_0`"]
    #[inline]
    pub fn is_plllosifg_0(&self) -> bool {
        *self == PLLLOSIFGR::PLLLOSIFG_0
    }
    #[doc = "Checks if the value of the field is `PLLLOSIFG_1`"]
    #[inline]
    pub fn is_plllosifg_1(&self) -> bool {
        *self == PLLLOSIFGR::PLLLOSIFG_1
    }
}
#[doc = "Possible values of the field `PLLOORIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PLLOORIFGR {
    #[doc = "No interrupt pending"]
    PLLOORIFG_0,
    #[doc = "Interrupt pending"]
    PLLOORIFG_1,
}
impl PLLOORIFGR {
    #[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 {
            PLLOORIFGR::PLLOORIFG_0 => false,
            PLLOORIFGR::PLLOORIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> PLLOORIFGR {
        match value {
            false => PLLOORIFGR::PLLOORIFG_0,
            true => PLLOORIFGR::PLLOORIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `PLLOORIFG_0`"]
    #[inline]
    pub fn is_plloorifg_0(&self) -> bool {
        *self == PLLOORIFGR::PLLOORIFG_0
    }
    #[doc = "Checks if the value of the field is `PLLOORIFG_1`"]
    #[inline]
    pub fn is_plloorifg_1(&self) -> bool {
        *self == PLLOORIFGR::PLLOORIFG_1
    }
}
#[doc = "Possible values of the field `CALIFG`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CALIFGR {
    #[doc = "REFCNT period counter not expired"]
    CALIFG_0,
    #[doc = "REFCNT period counter expired"]
    CALIFG_1,
}
impl CALIFGR {
    #[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 {
            CALIFGR::CALIFG_0 => false,
            CALIFGR::CALIFG_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> CALIFGR {
        match value {
            false => CALIFGR::CALIFG_0,
            true => CALIFGR::CALIFG_1,
        }
    }
    #[doc = "Checks if the value of the field is `CALIFG_0`"]
    #[inline]
    pub fn is_califg_0(&self) -> bool {
        *self == CALIFGR::CALIFG_0
    }
    #[doc = "Checks if the value of the field is `CALIFG_1`"]
    #[inline]
    pub fn is_califg_1(&self) -> bool {
        *self == CALIFGR::CALIFG_1
    }
}
impl R {
    #[doc = r" Value of the register as raw bits"]
    #[inline]
    pub fn bits(&self) -> u32 {
        self.bits
    }
    #[doc = "Bit 0 - LFXT oscillator fault flag"]
    #[inline]
    pub fn lfxtifg(&self) -> LFXTIFGR {
        LFXTIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 1 - HFXT oscillator fault flag"]
    #[inline]
    pub fn hfxtifg(&self) -> HFXTIFGR {
        HFXTIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 1;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 2 - HFXT2 oscillator fault flag"]
    #[inline]
    pub fn hfxt2ifg(&self) -> HFXT2IFGR {
        HFXT2IFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 2;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 5 - DCO external resistor short circuit fault flag."]
    #[inline]
    pub fn dcor_shtifg(&self) -> DCOR_SHTIFGR {
        DCOR_SHTIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 5;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 6 - DCO external resistor open circuit fault flag."]
    #[inline]
    pub fn dcor_opnifg(&self) -> DCOR_OPNIFGR {
        DCOR_OPNIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 6;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 8 - Start fault counter interrupt flag LFXT"]
    #[inline]
    pub fn fcntlfifg(&self) -> FCNTLFIFGR {
        FCNTLFIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 8;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 9 - Start fault counter interrupt flag HFXT"]
    #[inline]
    pub fn fcnthfifg(&self) -> FCNTHFIFGR {
        FCNTHFIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 9;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 11 - Start fault counter interrupt flag HFXT2"]
    #[inline]
    pub fn fcnthf2ifg(&self) -> FCNTHF2IFGR {
        FCNTHF2IFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 11;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 12 - PLL out-of-lock interrupt flag"]
    #[inline]
    pub fn plloolifg(&self) -> PLLOOLIFGR {
        PLLOOLIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 12;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 13 - PLL loss-of-signal interrupt flag"]
    #[inline]
    pub fn plllosifg(&self) -> PLLLOSIFGR {
        PLLLOSIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 13;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 14 - PLL out-of-range interrupt flag"]
    #[inline]
    pub fn plloorifg(&self) -> PLLOORIFGR {
        PLLOORIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 14;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 15 - REFCNT period counter expired"]
    #[inline]
    pub fn califg(&self) -> CALIFGR {
        CALIFGR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 15;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
}