#[doc = r" Value read from the register"]
pub struct R {
    bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
    bits: u32,
}
impl super::CSCTL2 {
    #[doc = r" Modifies the contents of the register"]
    #[inline]
    pub fn modify<F>(&self, f: F)
    where
        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
    {
        let bits = self.register.get();
        let r = R { bits: bits };
        let mut w = W { bits: bits };
        f(&r, &mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Reads the contents of the register"]
    #[inline]
    pub fn read(&self) -> R {
        R {
            bits: self.register.get(),
        }
    }
    #[doc = r" Writes to the register"]
    #[inline]
    pub fn write<F>(&self, f: F)
    where
        F: FnOnce(&mut W) -> &mut W,
    {
        let mut w = W::reset_value();
        f(&mut w);
        self.register.set(w.bits);
    }
    #[doc = r" Writes the reset value to the register"]
    #[inline]
    pub fn reset(&self) {
        self.write(|w| w)
    }
}
#[doc = "Possible values of the field `LFXTDRIVE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXTDRIVER {
    #[doc = "Lowest drive strength and current consumption LFXT oscillator."]
    LFXTDRIVE_0,
    #[doc = "Increased drive strength LFXT oscillator."]
    LFXTDRIVE_1,
    #[doc = "Increased drive strength LFXT oscillator."]
    LFXTDRIVE_2,
    #[doc = "Maximum drive strength and maximum current consumption LFXT oscillator."]
    LFXTDRIVE_3,
}
impl LFXTDRIVER {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            LFXTDRIVER::LFXTDRIVE_0 => 0,
            LFXTDRIVER::LFXTDRIVE_1 => 1,
            LFXTDRIVER::LFXTDRIVE_2 => 2,
            LFXTDRIVER::LFXTDRIVE_3 => 3,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> LFXTDRIVER {
        match value {
            0 => LFXTDRIVER::LFXTDRIVE_0,
            1 => LFXTDRIVER::LFXTDRIVE_1,
            2 => LFXTDRIVER::LFXTDRIVE_2,
            3 => LFXTDRIVER::LFXTDRIVE_3,
            _ => unreachable!(),
        }
    }
    #[doc = "Checks if the value of the field is `LFXTDRIVE_0`"]
    #[inline]
    pub fn is_lfxtdrive_0(&self) -> bool {
        *self == LFXTDRIVER::LFXTDRIVE_0
    }
    #[doc = "Checks if the value of the field is `LFXTDRIVE_1`"]
    #[inline]
    pub fn is_lfxtdrive_1(&self) -> bool {
        *self == LFXTDRIVER::LFXTDRIVE_1
    }
    #[doc = "Checks if the value of the field is `LFXTDRIVE_2`"]
    #[inline]
    pub fn is_lfxtdrive_2(&self) -> bool {
        *self == LFXTDRIVER::LFXTDRIVE_2
    }
    #[doc = "Checks if the value of the field is `LFXTDRIVE_3`"]
    #[inline]
    pub fn is_lfxtdrive_3(&self) -> bool {
        *self == LFXTDRIVER::LFXTDRIVE_3
    }
}
#[doc = "Possible values of the field `LFXTAGCOFF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXTAGCOFFR {
    #[doc = "AGC enabled."]
    LFXTAGCOFF_0,
    #[doc = "AGC disabled."]
    LFXTAGCOFF_1,
}
impl LFXTAGCOFFR {
    #[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 {
            LFXTAGCOFFR::LFXTAGCOFF_0 => false,
            LFXTAGCOFFR::LFXTAGCOFF_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXTAGCOFFR {
        match value {
            false => LFXTAGCOFFR::LFXTAGCOFF_0,
            true => LFXTAGCOFFR::LFXTAGCOFF_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXTAGCOFF_0`"]
    #[inline]
    pub fn is_lfxtagcoff_0(&self) -> bool {
        *self == LFXTAGCOFFR::LFXTAGCOFF_0
    }
    #[doc = "Checks if the value of the field is `LFXTAGCOFF_1`"]
    #[inline]
    pub fn is_lfxtagcoff_1(&self) -> bool {
        *self == LFXTAGCOFFR::LFXTAGCOFF_1
    }
}
#[doc = "Possible values of the field `LFXT_EN`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXT_ENR {
    #[doc = "LFXT is on if it is used as a source for ACLK, MCLK, HSMCLK , or SMCLK\r\r\nand is selected via the port selection and not in bypass mode of operation."]
    LFXT_EN_0,
    #[doc = "LFXT is on if LFXT is selected via the port selection and LFXT is not in\r\r\nbypass mode of operation."]
    LFXT_EN_1,
}
impl LFXT_ENR {
    #[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_ENR::LFXT_EN_0 => false,
            LFXT_ENR::LFXT_EN_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXT_ENR {
        match value {
            false => LFXT_ENR::LFXT_EN_0,
            true => LFXT_ENR::LFXT_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXT_EN_0`"]
    #[inline]
    pub fn is_lfxt_en_0(&self) -> bool {
        *self == LFXT_ENR::LFXT_EN_0
    }
    #[doc = "Checks if the value of the field is `LFXT_EN_1`"]
    #[inline]
    pub fn is_lfxt_en_1(&self) -> bool {
        *self == LFXT_ENR::LFXT_EN_1
    }
}
#[doc = "Possible values of the field `LFXTBYPASS`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LFXTBYPASSR {
    #[doc = "LFXT sourced by external crystal."]
    LFXTBYPASS_0,
    #[doc = "LFXT sourced by external square wave."]
    LFXTBYPASS_1,
}
impl LFXTBYPASSR {
    #[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 {
            LFXTBYPASSR::LFXTBYPASS_0 => false,
            LFXTBYPASSR::LFXTBYPASS_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> LFXTBYPASSR {
        match value {
            false => LFXTBYPASSR::LFXTBYPASS_0,
            true => LFXTBYPASSR::LFXTBYPASS_1,
        }
    }
    #[doc = "Checks if the value of the field is `LFXTBYPASS_0`"]
    #[inline]
    pub fn is_lfxtbypass_0(&self) -> bool {
        *self == LFXTBYPASSR::LFXTBYPASS_0
    }
    #[doc = "Checks if the value of the field is `LFXTBYPASS_1`"]
    #[inline]
    pub fn is_lfxtbypass_1(&self) -> bool {
        *self == LFXTBYPASSR::LFXTBYPASS_1
    }
}
#[doc = "Possible values of the field `HFXTDRIVE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXTDRIVER {
    #[doc = "To be used for HFXTFREQ setting 000b"]
    HFXTDRIVE_0,
    #[doc = "To be used for HFXTFREQ settings 001b to 110b"]
    HFXTDRIVE_1,
}
impl HFXTDRIVER {
    #[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 {
            HFXTDRIVER::HFXTDRIVE_0 => false,
            HFXTDRIVER::HFXTDRIVE_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXTDRIVER {
        match value {
            false => HFXTDRIVER::HFXTDRIVE_0,
            true => HFXTDRIVER::HFXTDRIVE_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXTDRIVE_0`"]
    #[inline]
    pub fn is_hfxtdrive_0(&self) -> bool {
        *self == HFXTDRIVER::HFXTDRIVE_0
    }
    #[doc = "Checks if the value of the field is `HFXTDRIVE_1`"]
    #[inline]
    pub fn is_hfxtdrive_1(&self) -> bool {
        *self == HFXTDRIVER::HFXTDRIVE_1
    }
}
#[doc = "Possible values of the field `HFXTFREQ`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXTFREQR {
    #[doc = "1 MHz to 4 MHz"]
    HFXTFREQ_0,
    #[doc = ">4 MHz to 8 MHz"]
    HFXTFREQ_1,
    #[doc = ">8 MHz to 16 MHz"]
    HFXTFREQ_2,
    #[doc = ">16 MHz to 24 MHz"]
    HFXTFREQ_3,
    #[doc = ">24 MHz to 32 MHz"]
    HFXTFREQ_4,
    #[doc = ">32 MHz to 40 MHz"]
    HFXTFREQ_5,
    #[doc = ">40 MHz to 48 MHz"]
    HFXTFREQ_6,
    #[doc = r" Reserved"]
    _Reserved(u8),
}
impl HFXTFREQR {
    #[doc = r" Value of the field as raw bits"]
    #[inline]
    pub fn bits(&self) -> u8 {
        match *self {
            HFXTFREQR::HFXTFREQ_0 => 0,
            HFXTFREQR::HFXTFREQ_1 => 1,
            HFXTFREQR::HFXTFREQ_2 => 2,
            HFXTFREQR::HFXTFREQ_3 => 3,
            HFXTFREQR::HFXTFREQ_4 => 4,
            HFXTFREQR::HFXTFREQ_5 => 5,
            HFXTFREQR::HFXTFREQ_6 => 6,
            HFXTFREQR::_Reserved(bits) => bits,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: u8) -> HFXTFREQR {
        match value {
            0 => HFXTFREQR::HFXTFREQ_0,
            1 => HFXTFREQR::HFXTFREQ_1,
            2 => HFXTFREQR::HFXTFREQ_2,
            3 => HFXTFREQR::HFXTFREQ_3,
            4 => HFXTFREQR::HFXTFREQ_4,
            5 => HFXTFREQR::HFXTFREQ_5,
            6 => HFXTFREQR::HFXTFREQ_6,
            i => HFXTFREQR::_Reserved(i),
        }
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_0`"]
    #[inline]
    pub fn is_hfxtfreq_0(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_0
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_1`"]
    #[inline]
    pub fn is_hfxtfreq_1(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_1
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_2`"]
    #[inline]
    pub fn is_hfxtfreq_2(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_2
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_3`"]
    #[inline]
    pub fn is_hfxtfreq_3(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_3
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_4`"]
    #[inline]
    pub fn is_hfxtfreq_4(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_4
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_5`"]
    #[inline]
    pub fn is_hfxtfreq_5(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_5
    }
    #[doc = "Checks if the value of the field is `HFXTFREQ_6`"]
    #[inline]
    pub fn is_hfxtfreq_6(&self) -> bool {
        *self == HFXTFREQR::HFXTFREQ_6
    }
}
#[doc = "Possible values of the field `HFXT_EN`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXT_ENR {
    #[doc = "HFXT is on if it is used as a source for MCLK, HSMCLK , or SMCLK and is selected via the port selection and not in bypass mode of operation."]
    HFXT_EN_0,
    #[doc = "HFXT is on if HFXT is selected via the port selection and HFXT is not in bypass mode of operation."]
    HFXT_EN_1,
}
impl HFXT_ENR {
    #[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_ENR::HFXT_EN_0 => false,
            HFXT_ENR::HFXT_EN_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXT_ENR {
        match value {
            false => HFXT_ENR::HFXT_EN_0,
            true => HFXT_ENR::HFXT_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXT_EN_0`"]
    #[inline]
    pub fn is_hfxt_en_0(&self) -> bool {
        *self == HFXT_ENR::HFXT_EN_0
    }
    #[doc = "Checks if the value of the field is `HFXT_EN_1`"]
    #[inline]
    pub fn is_hfxt_en_1(&self) -> bool {
        *self == HFXT_ENR::HFXT_EN_1
    }
}
#[doc = "Possible values of the field `HFXTBYPASS`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HFXTBYPASSR {
    #[doc = "HFXT sourced by external crystal."]
    HFXTBYPASS_0,
    #[doc = "HFXT sourced by external square wave."]
    HFXTBYPASS_1,
}
impl HFXTBYPASSR {
    #[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 {
            HFXTBYPASSR::HFXTBYPASS_0 => false,
            HFXTBYPASSR::HFXTBYPASS_1 => true,
        }
    }
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _from(value: bool) -> HFXTBYPASSR {
        match value {
            false => HFXTBYPASSR::HFXTBYPASS_0,
            true => HFXTBYPASSR::HFXTBYPASS_1,
        }
    }
    #[doc = "Checks if the value of the field is `HFXTBYPASS_0`"]
    #[inline]
    pub fn is_hfxtbypass_0(&self) -> bool {
        *self == HFXTBYPASSR::HFXTBYPASS_0
    }
    #[doc = "Checks if the value of the field is `HFXTBYPASS_1`"]
    #[inline]
    pub fn is_hfxtbypass_1(&self) -> bool {
        *self == HFXTBYPASSR::HFXTBYPASS_1
    }
}
#[doc = "Values that can be written to the field `LFXTDRIVE`"]
pub enum LFXTDRIVEW {
    #[doc = "Lowest drive strength and current consumption LFXT oscillator."]
    LFXTDRIVE_0,
    #[doc = "Increased drive strength LFXT oscillator."]
    LFXTDRIVE_1,
    #[doc = "Increased drive strength LFXT oscillator."]
    LFXTDRIVE_2,
    #[doc = "Maximum drive strength and maximum current consumption LFXT oscillator."]
    LFXTDRIVE_3,
}
impl LFXTDRIVEW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            LFXTDRIVEW::LFXTDRIVE_0 => 0,
            LFXTDRIVEW::LFXTDRIVE_1 => 1,
            LFXTDRIVEW::LFXTDRIVE_2 => 2,
            LFXTDRIVEW::LFXTDRIVE_3 => 3,
        }
    }
}
#[doc = r" Proxy"]
pub struct _LFXTDRIVEW<'a> {
    w: &'a mut W,
}
impl<'a> _LFXTDRIVEW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: LFXTDRIVEW) -> &'a mut W {
        {
            self.bits(variant._bits())
        }
    }
    #[doc = "Lowest drive strength and current consumption LFXT oscillator."]
    #[inline]
    pub fn lfxtdrive_0(self) -> &'a mut W {
        self.variant(LFXTDRIVEW::LFXTDRIVE_0)
    }
    #[doc = "Increased drive strength LFXT oscillator."]
    #[inline]
    pub fn lfxtdrive_1(self) -> &'a mut W {
        self.variant(LFXTDRIVEW::LFXTDRIVE_1)
    }
    #[doc = "Increased drive strength LFXT oscillator."]
    #[inline]
    pub fn lfxtdrive_2(self) -> &'a mut W {
        self.variant(LFXTDRIVEW::LFXTDRIVE_2)
    }
    #[doc = "Maximum drive strength and maximum current consumption LFXT oscillator."]
    #[inline]
    pub fn lfxtdrive_3(self) -> &'a mut W {
        self.variant(LFXTDRIVEW::LFXTDRIVE_3)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 3;
        const OFFSET: u8 = 0;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `LFXTAGCOFF`"]
pub enum LFXTAGCOFFW {
    #[doc = "AGC enabled."]
    LFXTAGCOFF_0,
    #[doc = "AGC disabled."]
    LFXTAGCOFF_1,
}
impl LFXTAGCOFFW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            LFXTAGCOFFW::LFXTAGCOFF_0 => false,
            LFXTAGCOFFW::LFXTAGCOFF_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _LFXTAGCOFFW<'a> {
    w: &'a mut W,
}
impl<'a> _LFXTAGCOFFW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: LFXTAGCOFFW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "AGC enabled."]
    #[inline]
    pub fn lfxtagcoff_0(self) -> &'a mut W {
        self.variant(LFXTAGCOFFW::LFXTAGCOFF_0)
    }
    #[doc = "AGC disabled."]
    #[inline]
    pub fn lfxtagcoff_1(self) -> &'a mut W {
        self.variant(LFXTAGCOFFW::LFXTAGCOFF_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 7;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `LFXT_EN`"]
pub enum LFXT_ENW {
    #[doc = "LFXT is on if it is used as a source for ACLK, MCLK, HSMCLK , or SMCLK\r\r\nand is selected via the port selection and not in bypass mode of operation."]
    LFXT_EN_0,
    #[doc = "LFXT is on if LFXT is selected via the port selection and LFXT is not in\r\r\nbypass mode of operation."]
    LFXT_EN_1,
}
impl LFXT_ENW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            LFXT_ENW::LFXT_EN_0 => false,
            LFXT_ENW::LFXT_EN_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _LFXT_ENW<'a> {
    w: &'a mut W,
}
impl<'a> _LFXT_ENW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: LFXT_ENW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "LFXT is on if it is used as a source for ACLK, MCLK, HSMCLK , or SMCLK and is selected via the port selection and not in bypass mode of operation."]
    #[inline]
    pub fn lfxt_en_0(self) -> &'a mut W {
        self.variant(LFXT_ENW::LFXT_EN_0)
    }
    #[doc = "LFXT is on if LFXT is selected via the port selection and LFXT is not in bypass mode of operation."]
    #[inline]
    pub fn lfxt_en_1(self) -> &'a mut W {
        self.variant(LFXT_ENW::LFXT_EN_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 8;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `LFXTBYPASS`"]
pub enum LFXTBYPASSW {
    #[doc = "LFXT sourced by external crystal."]
    LFXTBYPASS_0,
    #[doc = "LFXT sourced by external square wave."]
    LFXTBYPASS_1,
}
impl LFXTBYPASSW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            LFXTBYPASSW::LFXTBYPASS_0 => false,
            LFXTBYPASSW::LFXTBYPASS_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _LFXTBYPASSW<'a> {
    w: &'a mut W,
}
impl<'a> _LFXTBYPASSW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: LFXTBYPASSW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "LFXT sourced by external crystal."]
    #[inline]
    pub fn lfxtbypass_0(self) -> &'a mut W {
        self.variant(LFXTBYPASSW::LFXTBYPASS_0)
    }
    #[doc = "LFXT sourced by external square wave."]
    #[inline]
    pub fn lfxtbypass_1(self) -> &'a mut W {
        self.variant(LFXTBYPASSW::LFXTBYPASS_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 9;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `HFXTDRIVE`"]
pub enum HFXTDRIVEW {
    #[doc = "To be used for HFXTFREQ setting 000b"]
    HFXTDRIVE_0,
    #[doc = "To be used for HFXTFREQ settings 001b to 110b"]
    HFXTDRIVE_1,
}
impl HFXTDRIVEW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            HFXTDRIVEW::HFXTDRIVE_0 => false,
            HFXTDRIVEW::HFXTDRIVE_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _HFXTDRIVEW<'a> {
    w: &'a mut W,
}
impl<'a> _HFXTDRIVEW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: HFXTDRIVEW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "To be used for HFXTFREQ setting 000b"]
    #[inline]
    pub fn hfxtdrive_0(self) -> &'a mut W {
        self.variant(HFXTDRIVEW::HFXTDRIVE_0)
    }
    #[doc = "To be used for HFXTFREQ settings 001b to 110b"]
    #[inline]
    pub fn hfxtdrive_1(self) -> &'a mut W {
        self.variant(HFXTDRIVEW::HFXTDRIVE_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 16;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `HFXTFREQ`"]
pub enum HFXTFREQW {
    #[doc = "1 MHz to 4 MHz"]
    HFXTFREQ_0,
    #[doc = ">4 MHz to 8 MHz"]
    HFXTFREQ_1,
    #[doc = ">8 MHz to 16 MHz"]
    HFXTFREQ_2,
    #[doc = ">16 MHz to 24 MHz"]
    HFXTFREQ_3,
    #[doc = ">24 MHz to 32 MHz"]
    HFXTFREQ_4,
    #[doc = ">32 MHz to 40 MHz"]
    HFXTFREQ_5,
    #[doc = ">40 MHz to 48 MHz"]
    HFXTFREQ_6,
}
impl HFXTFREQW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> u8 {
        match *self {
            HFXTFREQW::HFXTFREQ_0 => 0,
            HFXTFREQW::HFXTFREQ_1 => 1,
            HFXTFREQW::HFXTFREQ_2 => 2,
            HFXTFREQW::HFXTFREQ_3 => 3,
            HFXTFREQW::HFXTFREQ_4 => 4,
            HFXTFREQW::HFXTFREQ_5 => 5,
            HFXTFREQW::HFXTFREQ_6 => 6,
        }
    }
}
#[doc = r" Proxy"]
pub struct _HFXTFREQW<'a> {
    w: &'a mut W,
}
impl<'a> _HFXTFREQW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: HFXTFREQW) -> &'a mut W {
        unsafe { self.bits(variant._bits()) }
    }
    #[doc = "1 MHz to 4 MHz"]
    #[inline]
    pub fn hfxtfreq_0(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_0)
    }
    #[doc = ">4 MHz to 8 MHz"]
    #[inline]
    pub fn hfxtfreq_1(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_1)
    }
    #[doc = ">8 MHz to 16 MHz"]
    #[inline]
    pub fn hfxtfreq_2(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_2)
    }
    #[doc = ">16 MHz to 24 MHz"]
    #[inline]
    pub fn hfxtfreq_3(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_3)
    }
    #[doc = ">24 MHz to 32 MHz"]
    #[inline]
    pub fn hfxtfreq_4(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_4)
    }
    #[doc = ">32 MHz to 40 MHz"]
    #[inline]
    pub fn hfxtfreq_5(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_5)
    }
    #[doc = ">40 MHz to 48 MHz"]
    #[inline]
    pub fn hfxtfreq_6(self) -> &'a mut W {
        self.variant(HFXTFREQW::HFXTFREQ_6)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        const MASK: u8 = 7;
        const OFFSET: u8 = 20;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `HFXT_EN`"]
pub enum HFXT_ENW {
    #[doc = "HFXT is on if it is used as a source for MCLK, HSMCLK , or SMCLK and is selected via the port selection and not in bypass mode of operation."]
    HFXT_EN_0,
    #[doc = "HFXT is on if HFXT is selected via the port selection and HFXT is not in bypass mode of operation."]
    HFXT_EN_1,
}
impl HFXT_ENW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            HFXT_ENW::HFXT_EN_0 => false,
            HFXT_ENW::HFXT_EN_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _HFXT_ENW<'a> {
    w: &'a mut W,
}
impl<'a> _HFXT_ENW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: HFXT_ENW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "HFXT is on if it is used as a source for MCLK, HSMCLK , or SMCLK and is selected via the port selection and not in bypass mode of operation."]
    #[inline]
    pub fn hfxt_en_0(self) -> &'a mut W {
        self.variant(HFXT_ENW::HFXT_EN_0)
    }
    #[doc = "HFXT is on if HFXT is selected via the port selection and HFXT is not in bypass mode of operation."]
    #[inline]
    pub fn hfxt_en_1(self) -> &'a mut W {
        self.variant(HFXT_ENW::HFXT_EN_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 24;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
#[doc = "Values that can be written to the field `HFXTBYPASS`"]
pub enum HFXTBYPASSW {
    #[doc = "HFXT sourced by external crystal."]
    HFXTBYPASS_0,
    #[doc = "HFXT sourced by external square wave."]
    HFXTBYPASS_1,
}
impl HFXTBYPASSW {
    #[allow(missing_docs)]
    #[doc(hidden)]
    #[inline]
    pub fn _bits(&self) -> bool {
        match *self {
            HFXTBYPASSW::HFXTBYPASS_0 => false,
            HFXTBYPASSW::HFXTBYPASS_1 => true,
        }
    }
}
#[doc = r" Proxy"]
pub struct _HFXTBYPASSW<'a> {
    w: &'a mut W,
}
impl<'a> _HFXTBYPASSW<'a> {
    #[doc = r" Writes `variant` to the field"]
    #[inline]
    pub fn variant(self, variant: HFXTBYPASSW) -> &'a mut W {
        {
            self.bit(variant._bits())
        }
    }
    #[doc = "HFXT sourced by external crystal."]
    #[inline]
    pub fn hfxtbypass_0(self) -> &'a mut W {
        self.variant(HFXTBYPASSW::HFXTBYPASS_0)
    }
    #[doc = "HFXT sourced by external square wave."]
    #[inline]
    pub fn hfxtbypass_1(self) -> &'a mut W {
        self.variant(HFXTBYPASSW::HFXTBYPASS_1)
    }
    #[doc = r" Sets the field bit"]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r" Clears the field bit"]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r" Writes raw bits to the field"]
    #[inline]
    pub fn bit(self, value: bool) -> &'a mut W {
        const MASK: bool = true;
        const OFFSET: u8 = 25;
        self.w.bits &= !((MASK as u32) << OFFSET);
        self.w.bits |= ((value & MASK) as u32) << OFFSET;
        self.w
    }
}
impl R {
    #[doc = r" Value of the register as raw bits"]
    #[inline]
    pub fn bits(&self) -> u32 {
        self.bits
    }
    #[doc = "Bits 0:1 - LFXT oscillator current can be adjusted to its drive needs"]
    #[inline]
    pub fn lfxtdrive(&self) -> LFXTDRIVER {
        LFXTDRIVER::_from({
            const MASK: u8 = 3;
            const OFFSET: u8 = 0;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bit 7 - Disables the automatic gain control of the LFXT crystal"]
    #[inline]
    pub fn lfxtagcoff(&self) -> LFXTAGCOFFR {
        LFXTAGCOFFR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 7;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 8 - Turns on the LFXT oscillator regardless if used as a clock resource"]
    #[inline]
    pub fn lfxt_en(&self) -> LFXT_ENR {
        LFXT_ENR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 8;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 9 - LFXT bypass select"]
    #[inline]
    pub fn lfxtbypass(&self) -> LFXTBYPASSR {
        LFXTBYPASSR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 9;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 16 - HFXT oscillator drive selection"]
    #[inline]
    pub fn hfxtdrive(&self) -> HFXTDRIVER {
        HFXTDRIVER::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 16;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bits 20:22 - HFXT frequency selection"]
    #[inline]
    pub fn hfxtfreq(&self) -> HFXTFREQR {
        HFXTFREQR::_from({
            const MASK: u8 = 7;
            const OFFSET: u8 = 20;
            ((self.bits >> OFFSET) & MASK as u32) as u8
        })
    }
    #[doc = "Bit 24 - Turns on the HFXT oscillator regardless if used as a clock resource"]
    #[inline]
    pub fn hfxt_en(&self) -> HFXT_ENR {
        HFXT_ENR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 24;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
    #[doc = "Bit 25 - HFXT bypass select"]
    #[inline]
    pub fn hfxtbypass(&self) -> HFXTBYPASSR {
        HFXTBYPASSR::_from({
            const MASK: bool = true;
            const OFFSET: u8 = 25;
            ((self.bits >> OFFSET) & MASK as u32) != 0
        })
    }
}
impl W {
    #[doc = r" Reset value of the register"]
    #[inline]
    pub fn reset_value() -> W {
        W { bits: 65539 }
    }
    #[doc = r" Writes raw bits to the register"]
    #[inline]
    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
        self.bits = bits;
        self
    }
    #[doc = "Bits 0:1 - LFXT oscillator current can be adjusted to its drive needs"]
    #[inline]
    pub fn lfxtdrive(&mut self) -> _LFXTDRIVEW {
        _LFXTDRIVEW { w: self }
    }
    #[doc = "Bit 7 - Disables the automatic gain control of the LFXT crystal"]
    #[inline]
    pub fn lfxtagcoff(&mut self) -> _LFXTAGCOFFW {
        _LFXTAGCOFFW { w: self }
    }
    #[doc = "Bit 8 - Turns on the LFXT oscillator regardless if used as a clock resource"]
    #[inline]
    pub fn lfxt_en(&mut self) -> _LFXT_ENW {
        _LFXT_ENW { w: self }
    }
    #[doc = "Bit 9 - LFXT bypass select"]
    #[inline]
    pub fn lfxtbypass(&mut self) -> _LFXTBYPASSW {
        _LFXTBYPASSW { w: self }
    }
    #[doc = "Bit 16 - HFXT oscillator drive selection"]
    #[inline]
    pub fn hfxtdrive(&mut self) -> _HFXTDRIVEW {
        _HFXTDRIVEW { w: self }
    }
    #[doc = "Bits 20:22 - HFXT frequency selection"]
    #[inline]
    pub fn hfxtfreq(&mut self) -> _HFXTFREQW {
        _HFXTFREQW { w: self }
    }
    #[doc = "Bit 24 - Turns on the HFXT oscillator regardless if used as a clock resource"]
    #[inline]
    pub fn hfxt_en(&mut self) -> _HFXT_ENW {
        _HFXT_ENW { w: self }
    }
    #[doc = "Bit 25 - HFXT bypass select"]
    #[inline]
    pub fn hfxtbypass(&mut self) -> _HFXTBYPASSW {
        _HFXTBYPASSW { w: self }
    }
}