#[doc = "Reader of register PLLCON0"]
pub type R = crate::R<u32, super::PLLCON0>;
#[doc = "Writer for register PLLCON0"]
pub type W = crate::W<u32, super::PLLCON0>;
#[doc = "Register PLLCON0 `reset()`'s with value 0x0003_0003"]
impl crate::ResetValue for super::PLLCON0 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x0003_0003
}
}
#[doc = "VCO Bypass\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum VCOBYP_A {
#[doc = "0: Normal operation, VCO is not bypassed"]
VALUE1 = 0,
#[doc = "1: Prescaler Mode, VCO is bypassed"]
VALUE2 = 1,
}
impl From<VCOBYP_A> for bool {
#[inline(always)]
fn from(variant: VCOBYP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `VCOBYP`"]
pub type VCOBYP_R = crate::R<bool, VCOBYP_A>;
impl VCOBYP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> VCOBYP_A {
match self.bits {
false => VCOBYP_A::VALUE1,
true => VCOBYP_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == VCOBYP_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == VCOBYP_A::VALUE2
}
}
#[doc = "Write proxy for field `VCOBYP`"]
pub struct VCOBYP_W<'a> {
w: &'a mut W,
}
impl<'a> VCOBYP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: VCOBYP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal operation, VCO is not bypassed"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(VCOBYP_A::VALUE1)
}
#[doc = "Prescaler Mode, VCO is bypassed"]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(VCOBYP_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "VCO Power Saving Mode\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum VCOPWD_A {
#[doc = "0: Normal behavior"]
VALUE1 = 0,
#[doc = "1: The VCO is put into a Power Saving Mode and can no longer be used. Only the Bypass and Prescaler Mode are active if previously selected."]
VALUE2 = 1,
}
impl From<VCOPWD_A> for bool {
#[inline(always)]
fn from(variant: VCOPWD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `VCOPWD`"]
pub type VCOPWD_R = crate::R<bool, VCOPWD_A>;
impl VCOPWD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> VCOPWD_A {
match self.bits {
false => VCOPWD_A::VALUE1,
true => VCOPWD_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == VCOPWD_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == VCOPWD_A::VALUE2
}
}
#[doc = "Write proxy for field `VCOPWD`"]
pub struct VCOPWD_W<'a> {
w: &'a mut W,
}
impl<'a> VCOPWD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: VCOPWD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal behavior"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(VCOPWD_A::VALUE1)
}
#[doc = "The VCO is put into a Power Saving Mode and can no longer be used. Only the Bypass and Prescaler Mode are active if previously selected."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(VCOPWD_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "VCO Trim Control\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum VCOTR_A {
#[doc = "0: VCO bandwidth is operation in the normal range. VCO output frequency is between 260 and 520 MHz for a input frequency between 8 and 16 MHz."]
VALUE1 = 0,
#[doc = "1: VCO bandwidth is operation in the test range. VCO output frequency is between 260 and 520 MHz for a input frequency between 8 and 16 MHz."]
VALUE2 = 1,
}
impl From<VCOTR_A> for bool {
#[inline(always)]
fn from(variant: VCOTR_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `VCOTR`"]
pub type VCOTR_R = crate::R<bool, VCOTR_A>;
impl VCOTR_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> VCOTR_A {
match self.bits {
false => VCOTR_A::VALUE1,
true => VCOTR_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == VCOTR_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == VCOTR_A::VALUE2
}
}
#[doc = "Write proxy for field `VCOTR`"]
pub struct VCOTR_W<'a> {
w: &'a mut W,
}
impl<'a> VCOTR_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: VCOTR_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "VCO bandwidth is operation in the normal range. VCO output frequency is between 260 and 520 MHz for a input frequency between 8 and 16 MHz."]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(VCOTR_A::VALUE1)
}
#[doc = "VCO bandwidth is operation in the test range. VCO output frequency is between 260 and 520 MHz for a input frequency between 8 and 16 MHz."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(VCOTR_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Disconnect Oscillator from VCO\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FINDIS_A {
#[doc = "0: connect oscillator to the VCO part"]
VALUE1 = 0,
#[doc = "1: disconnect oscillator from the VCO part."]
VALUE2 = 1,
}
impl From<FINDIS_A> for bool {
#[inline(always)]
fn from(variant: FINDIS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `FINDIS`"]
pub type FINDIS_R = crate::R<bool, FINDIS_A>;
impl FINDIS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FINDIS_A {
match self.bits {
false => FINDIS_A::VALUE1,
true => FINDIS_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == FINDIS_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == FINDIS_A::VALUE2
}
}
#[doc = "Write proxy for field `FINDIS`"]
pub struct FINDIS_W<'a> {
w: &'a mut W,
}
impl<'a> FINDIS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FINDIS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "connect oscillator to the VCO part"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(FINDIS_A::VALUE1)
}
#[doc = "disconnect oscillator from the VCO part."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(FINDIS_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Oscillator Disconnect Disable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OSCDISCDIS_A {
#[doc = "0: In case of a PLL loss-of-lock bit FINDIS is set"]
VALUE1 = 0,
#[doc = "1: In case of a PLL loss-of-lock bit FINDIS is cleared"]
VALUE2 = 1,
}
impl From<OSCDISCDIS_A> for bool {
#[inline(always)]
fn from(variant: OSCDISCDIS_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OSCDISCDIS`"]
pub type OSCDISCDIS_R = crate::R<bool, OSCDISCDIS_A>;
impl OSCDISCDIS_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OSCDISCDIS_A {
match self.bits {
false => OSCDISCDIS_A::VALUE1,
true => OSCDISCDIS_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == OSCDISCDIS_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == OSCDISCDIS_A::VALUE2
}
}
#[doc = "Write proxy for field `OSCDISCDIS`"]
pub struct OSCDISCDIS_W<'a> {
w: &'a mut W,
}
impl<'a> OSCDISCDIS_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OSCDISCDIS_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "In case of a PLL loss-of-lock bit FINDIS is set"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(OSCDISCDIS_A::VALUE1)
}
#[doc = "In case of a PLL loss-of-lock bit FINDIS is cleared"]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(OSCDISCDIS_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "PLL Power Saving Mode\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PLLPWD_A {
#[doc = "0: Normal behavior"]
VALUE1 = 0,
#[doc = "1: The complete PLL block is put into a Power Saving Mode and can no longer be used. Only the Bypass Mode is active if previously selected."]
VALUE2 = 1,
}
impl From<PLLPWD_A> for bool {
#[inline(always)]
fn from(variant: PLLPWD_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `PLLPWD`"]
pub type PLLPWD_R = crate::R<bool, PLLPWD_A>;
impl PLLPWD_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> PLLPWD_A {
match self.bits {
false => PLLPWD_A::VALUE1,
true => PLLPWD_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == PLLPWD_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == PLLPWD_A::VALUE2
}
}
#[doc = "Write proxy for field `PLLPWD`"]
pub struct PLLPWD_W<'a> {
w: &'a mut W,
}
impl<'a> PLLPWD_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLLPWD_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Normal behavior"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(PLLPWD_A::VALUE1)
}
#[doc = "The complete PLL block is put into a Power Saving Mode and can no longer be used. Only the Bypass Mode is active if previously selected."]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(PLLPWD_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Oscillator Watchdog Reset\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OSCRES_A {
#[doc = "0: The Oscillator Watchdog of the PLL is not cleared and remains active"]
VALUE1 = 0,
#[doc = "1: The Oscillator Watchdog of the PLL is cleared and restarted"]
VALUE2 = 1,
}
impl From<OSCRES_A> for bool {
#[inline(always)]
fn from(variant: OSCRES_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `OSCRES`"]
pub type OSCRES_R = crate::R<bool, OSCRES_A>;
impl OSCRES_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> OSCRES_A {
match self.bits {
false => OSCRES_A::VALUE1,
true => OSCRES_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == OSCRES_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == OSCRES_A::VALUE2
}
}
#[doc = "Write proxy for field `OSCRES`"]
pub struct OSCRES_W<'a> {
w: &'a mut W,
}
impl<'a> OSCRES_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: OSCRES_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "The Oscillator Watchdog of the PLL is not cleared and remains active"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(OSCRES_A::VALUE1)
}
#[doc = "The Oscillator Watchdog of the PLL is cleared and restarted"]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(OSCRES_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
self.w
}
}
#[doc = "Write proxy for field `RESLD`"]
pub struct RESLD_W<'a> {
w: &'a mut W,
}
impl<'a> RESLD_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
self.w
}
}
#[doc = "Automatic Oscillator Calibration Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AOTREN_A {
#[doc = "0: Disable"]
VALUE1 = 0,
#[doc = "1: Enable"]
VALUE2 = 1,
}
impl From<AOTREN_A> for bool {
#[inline(always)]
fn from(variant: AOTREN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `AOTREN`"]
pub type AOTREN_R = crate::R<bool, AOTREN_A>;
impl AOTREN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> AOTREN_A {
match self.bits {
false => AOTREN_A::VALUE1,
true => AOTREN_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == AOTREN_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == AOTREN_A::VALUE2
}
}
#[doc = "Write proxy for field `AOTREN`"]
pub struct AOTREN_W<'a> {
w: &'a mut W,
}
impl<'a> AOTREN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: AOTREN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Disable"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(AOTREN_A::VALUE1)
}
#[doc = "Enable"]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(AOTREN_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
self.w
}
}
#[doc = "Factory Oscillator Calibration\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum FOTR_A {
#[doc = "0: No effect"]
VALUE1 = 0,
#[doc = "1: Force fixed-value trimming"]
VALUE2 = 1,
}
impl From<FOTR_A> for bool {
#[inline(always)]
fn from(variant: FOTR_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `FOTR`"]
pub type FOTR_R = crate::R<bool, FOTR_A>;
impl FOTR_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> FOTR_A {
match self.bits {
false => FOTR_A::VALUE1,
true => FOTR_A::VALUE2,
}
}
#[doc = "Checks if the value of the field is `VALUE1`"]
#[inline(always)]
pub fn is_value1(&self) -> bool {
*self == FOTR_A::VALUE1
}
#[doc = "Checks if the value of the field is `VALUE2`"]
#[inline(always)]
pub fn is_value2(&self) -> bool {
*self == FOTR_A::VALUE2
}
}
#[doc = "Write proxy for field `FOTR`"]
pub struct FOTR_W<'a> {
w: &'a mut W,
}
impl<'a> FOTR_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: FOTR_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "No effect"]
#[inline(always)]
pub fn value1(self) -> &'a mut W {
self.variant(FOTR_A::VALUE1)
}
#[doc = "Force fixed-value trimming"]
#[inline(always)]
pub fn value2(self) -> &'a mut W {
self.variant(FOTR_A::VALUE2)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
impl R {
#[doc = "Bit 0 - VCO Bypass"]
#[inline(always)]
pub fn vcobyp(&self) -> VCOBYP_R {
VCOBYP_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - VCO Power Saving Mode"]
#[inline(always)]
pub fn vcopwd(&self) -> VCOPWD_R {
VCOPWD_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - VCO Trim Control"]
#[inline(always)]
pub fn vcotr(&self) -> VCOTR_R {
VCOTR_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 4 - Disconnect Oscillator from VCO"]
#[inline(always)]
pub fn findis(&self) -> FINDIS_R {
FINDIS_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 6 - Oscillator Disconnect Disable"]
#[inline(always)]
pub fn oscdiscdis(&self) -> OSCDISCDIS_R {
OSCDISCDIS_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 16 - PLL Power Saving Mode"]
#[inline(always)]
pub fn pllpwd(&self) -> PLLPWD_R {
PLLPWD_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - Oscillator Watchdog Reset"]
#[inline(always)]
pub fn oscres(&self) -> OSCRES_R {
OSCRES_R::new(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 19 - Automatic Oscillator Calibration Enable"]
#[inline(always)]
pub fn aotren(&self) -> AOTREN_R {
AOTREN_R::new(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 20 - Factory Oscillator Calibration"]
#[inline(always)]
pub fn fotr(&self) -> FOTR_R {
FOTR_R::new(((self.bits >> 20) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - VCO Bypass"]
#[inline(always)]
pub fn vcobyp(&mut self) -> VCOBYP_W {
VCOBYP_W { w: self }
}
#[doc = "Bit 1 - VCO Power Saving Mode"]
#[inline(always)]
pub fn vcopwd(&mut self) -> VCOPWD_W {
VCOPWD_W { w: self }
}
#[doc = "Bit 2 - VCO Trim Control"]
#[inline(always)]
pub fn vcotr(&mut self) -> VCOTR_W {
VCOTR_W { w: self }
}
#[doc = "Bit 4 - Disconnect Oscillator from VCO"]
#[inline(always)]
pub fn findis(&mut self) -> FINDIS_W {
FINDIS_W { w: self }
}
#[doc = "Bit 6 - Oscillator Disconnect Disable"]
#[inline(always)]
pub fn oscdiscdis(&mut self) -> OSCDISCDIS_W {
OSCDISCDIS_W { w: self }
}
#[doc = "Bit 16 - PLL Power Saving Mode"]
#[inline(always)]
pub fn pllpwd(&mut self) -> PLLPWD_W {
PLLPWD_W { w: self }
}
#[doc = "Bit 17 - Oscillator Watchdog Reset"]
#[inline(always)]
pub fn oscres(&mut self) -> OSCRES_W {
OSCRES_W { w: self }
}
#[doc = "Bit 18 - Restart VCO Lock Detection"]
#[inline(always)]
pub fn resld(&mut self) -> RESLD_W {
RESLD_W { w: self }
}
#[doc = "Bit 19 - Automatic Oscillator Calibration Enable"]
#[inline(always)]
pub fn aotren(&mut self) -> AOTREN_W {
AOTREN_W { w: self }
}
#[doc = "Bit 20 - Factory Oscillator Calibration"]
#[inline(always)]
pub fn fotr(&mut self) -> FOTR_W {
FOTR_W { w: self }
}
}