1374 lines
36 KiB
Rust
1374 lines
36 KiB
Rust
#[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::CSIE {
|
|
#[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 `LFXTIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum LFXTIER {
|
|
#[doc = "Interrupt disabled"]
|
|
LFXTIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
LFXTIE_1,
|
|
}
|
|
impl LFXTIER {
|
|
#[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 {
|
|
LFXTIER::LFXTIE_0 => false,
|
|
LFXTIER::LFXTIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> LFXTIER {
|
|
match value {
|
|
false => LFXTIER::LFXTIE_0,
|
|
true => LFXTIER::LFXTIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `LFXTIE_0`"]
|
|
#[inline]
|
|
pub fn is_lfxtie_0(&self) -> bool {
|
|
*self == LFXTIER::LFXTIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `LFXTIE_1`"]
|
|
#[inline]
|
|
pub fn is_lfxtie_1(&self) -> bool {
|
|
*self == LFXTIER::LFXTIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `HFXTIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum HFXTIER {
|
|
#[doc = "Interrupt disabled"]
|
|
HFXTIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
HFXTIE_1,
|
|
}
|
|
impl HFXTIER {
|
|
#[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 {
|
|
HFXTIER::HFXTIE_0 => false,
|
|
HFXTIER::HFXTIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> HFXTIER {
|
|
match value {
|
|
false => HFXTIER::HFXTIE_0,
|
|
true => HFXTIER::HFXTIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXTIE_0`"]
|
|
#[inline]
|
|
pub fn is_hfxtie_0(&self) -> bool {
|
|
*self == HFXTIER::HFXTIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXTIE_1`"]
|
|
#[inline]
|
|
pub fn is_hfxtie_1(&self) -> bool {
|
|
*self == HFXTIER::HFXTIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `HFXT2IE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum HFXT2IER {
|
|
#[doc = "Interrupt disabled"]
|
|
HFXT2IE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
HFXT2IE_1,
|
|
}
|
|
impl HFXT2IER {
|
|
#[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 {
|
|
HFXT2IER::HFXT2IE_0 => false,
|
|
HFXT2IER::HFXT2IE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> HFXT2IER {
|
|
match value {
|
|
false => HFXT2IER::HFXT2IE_0,
|
|
true => HFXT2IER::HFXT2IE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXT2IE_0`"]
|
|
#[inline]
|
|
pub fn is_hfxt2ie_0(&self) -> bool {
|
|
*self == HFXT2IER::HFXT2IE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `HFXT2IE_1`"]
|
|
#[inline]
|
|
pub fn is_hfxt2ie_1(&self) -> bool {
|
|
*self == HFXT2IER::HFXT2IE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `DCOR_OPNIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum DCOR_OPNIER {
|
|
#[doc = "Interrupt disabled"]
|
|
DCOR_OPNIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
DCOR_OPNIE_1,
|
|
}
|
|
impl DCOR_OPNIER {
|
|
#[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_OPNIER::DCOR_OPNIE_0 => false,
|
|
DCOR_OPNIER::DCOR_OPNIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> DCOR_OPNIER {
|
|
match value {
|
|
false => DCOR_OPNIER::DCOR_OPNIE_0,
|
|
true => DCOR_OPNIER::DCOR_OPNIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_OPNIE_0`"]
|
|
#[inline]
|
|
pub fn is_dcor_opnie_0(&self) -> bool {
|
|
*self == DCOR_OPNIER::DCOR_OPNIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `DCOR_OPNIE_1`"]
|
|
#[inline]
|
|
pub fn is_dcor_opnie_1(&self) -> bool {
|
|
*self == DCOR_OPNIER::DCOR_OPNIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTLFIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTLFIER {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTLFIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTLFIE_1,
|
|
}
|
|
impl FCNTLFIER {
|
|
#[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 {
|
|
FCNTLFIER::FCNTLFIE_0 => false,
|
|
FCNTLFIER::FCNTLFIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTLFIER {
|
|
match value {
|
|
false => FCNTLFIER::FCNTLFIE_0,
|
|
true => FCNTLFIER::FCNTLFIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTLFIE_0`"]
|
|
#[inline]
|
|
pub fn is_fcntlfie_0(&self) -> bool {
|
|
*self == FCNTLFIER::FCNTLFIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTLFIE_1`"]
|
|
#[inline]
|
|
pub fn is_fcntlfie_1(&self) -> bool {
|
|
*self == FCNTLFIER::FCNTLFIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTHFIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTHFIER {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTHFIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTHFIE_1,
|
|
}
|
|
impl FCNTHFIER {
|
|
#[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 {
|
|
FCNTHFIER::FCNTHFIE_0 => false,
|
|
FCNTHFIER::FCNTHFIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTHFIER {
|
|
match value {
|
|
false => FCNTHFIER::FCNTHFIE_0,
|
|
true => FCNTHFIER::FCNTHFIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHFIE_0`"]
|
|
#[inline]
|
|
pub fn is_fcnthfie_0(&self) -> bool {
|
|
*self == FCNTHFIER::FCNTHFIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHFIE_1`"]
|
|
#[inline]
|
|
pub fn is_fcnthfie_1(&self) -> bool {
|
|
*self == FCNTHFIER::FCNTHFIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `FCNTHF2IE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum FCNTHF2IER {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTHF2IE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTHF2IE_1,
|
|
}
|
|
impl FCNTHF2IER {
|
|
#[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 {
|
|
FCNTHF2IER::FCNTHF2IE_0 => false,
|
|
FCNTHF2IER::FCNTHF2IE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> FCNTHF2IER {
|
|
match value {
|
|
false => FCNTHF2IER::FCNTHF2IE_0,
|
|
true => FCNTHF2IER::FCNTHF2IE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHF2IE_0`"]
|
|
#[inline]
|
|
pub fn is_fcnthf2ie_0(&self) -> bool {
|
|
*self == FCNTHF2IER::FCNTHF2IE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `FCNTHF2IE_1`"]
|
|
#[inline]
|
|
pub fn is_fcnthf2ie_1(&self) -> bool {
|
|
*self == FCNTHF2IER::FCNTHF2IE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLOOLIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLOOLIER {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLOOLIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLOOLIE_1,
|
|
}
|
|
impl PLLOOLIER {
|
|
#[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 {
|
|
PLLOOLIER::PLLOOLIE_0 => false,
|
|
PLLOOLIER::PLLOOLIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLOOLIER {
|
|
match value {
|
|
false => PLLOOLIER::PLLOOLIE_0,
|
|
true => PLLOOLIER::PLLOOLIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOOLIE_0`"]
|
|
#[inline]
|
|
pub fn is_plloolie_0(&self) -> bool {
|
|
*self == PLLOOLIER::PLLOOLIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOOLIE_1`"]
|
|
#[inline]
|
|
pub fn is_plloolie_1(&self) -> bool {
|
|
*self == PLLOOLIER::PLLOOLIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLLOSIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLLOSIER {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLLOSIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLLOSIE_1,
|
|
}
|
|
impl PLLLOSIER {
|
|
#[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 {
|
|
PLLLOSIER::PLLLOSIE_0 => false,
|
|
PLLLOSIER::PLLLOSIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLLOSIER {
|
|
match value {
|
|
false => PLLLOSIER::PLLLOSIE_0,
|
|
true => PLLLOSIER::PLLLOSIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLLOSIE_0`"]
|
|
#[inline]
|
|
pub fn is_plllosie_0(&self) -> bool {
|
|
*self == PLLLOSIER::PLLLOSIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLLOSIE_1`"]
|
|
#[inline]
|
|
pub fn is_plllosie_1(&self) -> bool {
|
|
*self == PLLLOSIER::PLLLOSIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `PLLOORIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum PLLOORIER {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLOORIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLOORIE_1,
|
|
}
|
|
impl PLLOORIER {
|
|
#[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 {
|
|
PLLOORIER::PLLOORIE_0 => false,
|
|
PLLOORIER::PLLOORIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> PLLOORIER {
|
|
match value {
|
|
false => PLLOORIER::PLLOORIE_0,
|
|
true => PLLOORIER::PLLOORIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOORIE_0`"]
|
|
#[inline]
|
|
pub fn is_plloorie_0(&self) -> bool {
|
|
*self == PLLOORIER::PLLOORIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `PLLOORIE_1`"]
|
|
#[inline]
|
|
pub fn is_plloorie_1(&self) -> bool {
|
|
*self == PLLOORIER::PLLOORIE_1
|
|
}
|
|
}
|
|
#[doc = "Possible values of the field `CALIE`"]
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum CALIER {
|
|
#[doc = "Interrupt disabled"]
|
|
CALIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
CALIE_1,
|
|
}
|
|
impl CALIER {
|
|
#[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 {
|
|
CALIER::CALIE_0 => false,
|
|
CALIER::CALIE_1 => true,
|
|
}
|
|
}
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _from(value: bool) -> CALIER {
|
|
match value {
|
|
false => CALIER::CALIE_0,
|
|
true => CALIER::CALIE_1,
|
|
}
|
|
}
|
|
#[doc = "Checks if the value of the field is `CALIE_0`"]
|
|
#[inline]
|
|
pub fn is_calie_0(&self) -> bool {
|
|
*self == CALIER::CALIE_0
|
|
}
|
|
#[doc = "Checks if the value of the field is `CALIE_1`"]
|
|
#[inline]
|
|
pub fn is_calie_1(&self) -> bool {
|
|
*self == CALIER::CALIE_1
|
|
}
|
|
}
|
|
#[doc = "Values that can be written to the field `LFXTIE`"]
|
|
pub enum LFXTIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
LFXTIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
LFXTIE_1,
|
|
}
|
|
impl LFXTIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
LFXTIEW::LFXTIE_0 => false,
|
|
LFXTIEW::LFXTIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _LFXTIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _LFXTIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: LFXTIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn lfxtie_0(self) -> &'a mut W {
|
|
self.variant(LFXTIEW::LFXTIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn lfxtie_1(self) -> &'a mut W {
|
|
self.variant(LFXTIEW::LFXTIE_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 = 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 `HFXTIE`"]
|
|
pub enum HFXTIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
HFXTIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
HFXTIE_1,
|
|
}
|
|
impl HFXTIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
HFXTIEW::HFXTIE_0 => false,
|
|
HFXTIEW::HFXTIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _HFXTIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _HFXTIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: HFXTIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn hfxtie_0(self) -> &'a mut W {
|
|
self.variant(HFXTIEW::HFXTIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn hfxtie_1(self) -> &'a mut W {
|
|
self.variant(HFXTIEW::HFXTIE_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 = 1;
|
|
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 `HFXT2IE`"]
|
|
pub enum HFXT2IEW {
|
|
#[doc = "Interrupt disabled"]
|
|
HFXT2IE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
HFXT2IE_1,
|
|
}
|
|
impl HFXT2IEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
HFXT2IEW::HFXT2IE_0 => false,
|
|
HFXT2IEW::HFXT2IE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _HFXT2IEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _HFXT2IEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: HFXT2IEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn hfxt2ie_0(self) -> &'a mut W {
|
|
self.variant(HFXT2IEW::HFXT2IE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn hfxt2ie_1(self) -> &'a mut W {
|
|
self.variant(HFXT2IEW::HFXT2IE_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 = 2;
|
|
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 `DCOR_OPNIE`"]
|
|
pub enum DCOR_OPNIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
DCOR_OPNIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
DCOR_OPNIE_1,
|
|
}
|
|
impl DCOR_OPNIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
DCOR_OPNIEW::DCOR_OPNIE_0 => false,
|
|
DCOR_OPNIEW::DCOR_OPNIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _DCOR_OPNIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _DCOR_OPNIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: DCOR_OPNIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn dcor_opnie_0(self) -> &'a mut W {
|
|
self.variant(DCOR_OPNIEW::DCOR_OPNIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn dcor_opnie_1(self) -> &'a mut W {
|
|
self.variant(DCOR_OPNIEW::DCOR_OPNIE_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 = 6;
|
|
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 `FCNTLFIE`"]
|
|
pub enum FCNTLFIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTLFIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTLFIE_1,
|
|
}
|
|
impl FCNTLFIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
FCNTLFIEW::FCNTLFIE_0 => false,
|
|
FCNTLFIEW::FCNTLFIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _FCNTLFIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _FCNTLFIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: FCNTLFIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn fcntlfie_0(self) -> &'a mut W {
|
|
self.variant(FCNTLFIEW::FCNTLFIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn fcntlfie_1(self) -> &'a mut W {
|
|
self.variant(FCNTLFIEW::FCNTLFIE_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 `FCNTHFIE`"]
|
|
pub enum FCNTHFIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTHFIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTHFIE_1,
|
|
}
|
|
impl FCNTHFIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
FCNTHFIEW::FCNTHFIE_0 => false,
|
|
FCNTHFIEW::FCNTHFIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _FCNTHFIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _FCNTHFIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: FCNTHFIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn fcnthfie_0(self) -> &'a mut W {
|
|
self.variant(FCNTHFIEW::FCNTHFIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn fcnthfie_1(self) -> &'a mut W {
|
|
self.variant(FCNTHFIEW::FCNTHFIE_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 `FCNTHF2IE`"]
|
|
pub enum FCNTHF2IEW {
|
|
#[doc = "Interrupt disabled"]
|
|
FCNTHF2IE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
FCNTHF2IE_1,
|
|
}
|
|
impl FCNTHF2IEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
FCNTHF2IEW::FCNTHF2IE_0 => false,
|
|
FCNTHF2IEW::FCNTHF2IE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _FCNTHF2IEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _FCNTHF2IEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: FCNTHF2IEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn fcnthf2ie_0(self) -> &'a mut W {
|
|
self.variant(FCNTHF2IEW::FCNTHF2IE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn fcnthf2ie_1(self) -> &'a mut W {
|
|
self.variant(FCNTHF2IEW::FCNTHF2IE_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 = 10;
|
|
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 `PLLOOLIE`"]
|
|
pub enum PLLOOLIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLOOLIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLOOLIE_1,
|
|
}
|
|
impl PLLOOLIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
PLLOOLIEW::PLLOOLIE_0 => false,
|
|
PLLOOLIEW::PLLOOLIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _PLLOOLIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _PLLOOLIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: PLLOOLIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn plloolie_0(self) -> &'a mut W {
|
|
self.variant(PLLOOLIEW::PLLOOLIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn plloolie_1(self) -> &'a mut W {
|
|
self.variant(PLLOOLIEW::PLLOOLIE_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 = 12;
|
|
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 `PLLLOSIE`"]
|
|
pub enum PLLLOSIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLLOSIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLLOSIE_1,
|
|
}
|
|
impl PLLLOSIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
PLLLOSIEW::PLLLOSIE_0 => false,
|
|
PLLLOSIEW::PLLLOSIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _PLLLOSIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _PLLLOSIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: PLLLOSIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn plllosie_0(self) -> &'a mut W {
|
|
self.variant(PLLLOSIEW::PLLLOSIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn plllosie_1(self) -> &'a mut W {
|
|
self.variant(PLLLOSIEW::PLLLOSIE_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 = 13;
|
|
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 `PLLOORIE`"]
|
|
pub enum PLLOORIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
PLLOORIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
PLLOORIE_1,
|
|
}
|
|
impl PLLOORIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
PLLOORIEW::PLLOORIE_0 => false,
|
|
PLLOORIEW::PLLOORIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _PLLOORIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _PLLOORIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: PLLOORIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn plloorie_0(self) -> &'a mut W {
|
|
self.variant(PLLOORIEW::PLLOORIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn plloorie_1(self) -> &'a mut W {
|
|
self.variant(PLLOORIEW::PLLOORIE_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 = 14;
|
|
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 `CALIE`"]
|
|
pub enum CALIEW {
|
|
#[doc = "Interrupt disabled"]
|
|
CALIE_0,
|
|
#[doc = "Interrupt enabled"]
|
|
CALIE_1,
|
|
}
|
|
impl CALIEW {
|
|
#[allow(missing_docs)]
|
|
#[doc(hidden)]
|
|
#[inline]
|
|
pub fn _bits(&self) -> bool {
|
|
match *self {
|
|
CALIEW::CALIE_0 => false,
|
|
CALIEW::CALIE_1 => true,
|
|
}
|
|
}
|
|
}
|
|
#[doc = r" Proxy"]
|
|
pub struct _CALIEW<'a> {
|
|
w: &'a mut W,
|
|
}
|
|
impl<'a> _CALIEW<'a> {
|
|
#[doc = r" Writes `variant` to the field"]
|
|
#[inline]
|
|
pub fn variant(self, variant: CALIEW) -> &'a mut W {
|
|
{
|
|
self.bit(variant._bits())
|
|
}
|
|
}
|
|
#[doc = "Interrupt disabled"]
|
|
#[inline]
|
|
pub fn calie_0(self) -> &'a mut W {
|
|
self.variant(CALIEW::CALIE_0)
|
|
}
|
|
#[doc = "Interrupt enabled"]
|
|
#[inline]
|
|
pub fn calie_1(self) -> &'a mut W {
|
|
self.variant(CALIEW::CALIE_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 = 15;
|
|
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 = "Bit 0 - LFXT oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn lfxtie(&self) -> LFXTIER {
|
|
LFXTIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 0;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 1 - HFXT oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn hfxtie(&self) -> HFXTIER {
|
|
HFXTIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 1;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 2 - HFXT2 oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn hfxt2ie(&self) -> HFXT2IER {
|
|
HFXT2IER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 2;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 6 - DCO external resistor open circuit fault flag interrupt enable."]
|
|
#[inline]
|
|
pub fn dcor_opnie(&self) -> DCOR_OPNIER {
|
|
DCOR_OPNIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 6;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 8 - Start fault counter interrupt enable LFXT"]
|
|
#[inline]
|
|
pub fn fcntlfie(&self) -> FCNTLFIER {
|
|
FCNTLFIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 8;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 9 - Start fault counter interrupt enable HFXT"]
|
|
#[inline]
|
|
pub fn fcnthfie(&self) -> FCNTHFIER {
|
|
FCNTHFIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 9;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 10 - Start fault counter interrupt enable HFXT2"]
|
|
#[inline]
|
|
pub fn fcnthf2ie(&self) -> FCNTHF2IER {
|
|
FCNTHF2IER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 10;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 12 - PLL out-of-lock interrupt enable"]
|
|
#[inline]
|
|
pub fn plloolie(&self) -> PLLOOLIER {
|
|
PLLOOLIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 12;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 13 - PLL loss-of-signal interrupt enable"]
|
|
#[inline]
|
|
pub fn plllosie(&self) -> PLLLOSIER {
|
|
PLLLOSIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 13;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 14 - PLL out-of-range interrupt enable"]
|
|
#[inline]
|
|
pub fn plloorie(&self) -> PLLOORIER {
|
|
PLLOORIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 14;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
#[doc = "Bit 15 - REFCNT period counter interrupt enable"]
|
|
#[inline]
|
|
pub fn calie(&self) -> CALIER {
|
|
CALIER::_from({
|
|
const MASK: bool = true;
|
|
const OFFSET: u8 = 15;
|
|
((self.bits >> OFFSET) & MASK as u32) != 0
|
|
})
|
|
}
|
|
}
|
|
impl W {
|
|
#[doc = r" Reset value of the register"]
|
|
#[inline]
|
|
pub fn reset_value() -> W {
|
|
W { bits: 0 }
|
|
}
|
|
#[doc = r" Writes raw bits to the register"]
|
|
#[inline]
|
|
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
|
|
self.bits = bits;
|
|
self
|
|
}
|
|
#[doc = "Bit 0 - LFXT oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn lfxtie(&mut self) -> _LFXTIEW {
|
|
_LFXTIEW { w: self }
|
|
}
|
|
#[doc = "Bit 1 - HFXT oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn hfxtie(&mut self) -> _HFXTIEW {
|
|
_HFXTIEW { w: self }
|
|
}
|
|
#[doc = "Bit 2 - HFXT2 oscillator fault flag interrupt enable"]
|
|
#[inline]
|
|
pub fn hfxt2ie(&mut self) -> _HFXT2IEW {
|
|
_HFXT2IEW { w: self }
|
|
}
|
|
#[doc = "Bit 6 - DCO external resistor open circuit fault flag interrupt enable."]
|
|
#[inline]
|
|
pub fn dcor_opnie(&mut self) -> _DCOR_OPNIEW {
|
|
_DCOR_OPNIEW { w: self }
|
|
}
|
|
#[doc = "Bit 8 - Start fault counter interrupt enable LFXT"]
|
|
#[inline]
|
|
pub fn fcntlfie(&mut self) -> _FCNTLFIEW {
|
|
_FCNTLFIEW { w: self }
|
|
}
|
|
#[doc = "Bit 9 - Start fault counter interrupt enable HFXT"]
|
|
#[inline]
|
|
pub fn fcnthfie(&mut self) -> _FCNTHFIEW {
|
|
_FCNTHFIEW { w: self }
|
|
}
|
|
#[doc = "Bit 10 - Start fault counter interrupt enable HFXT2"]
|
|
#[inline]
|
|
pub fn fcnthf2ie(&mut self) -> _FCNTHF2IEW {
|
|
_FCNTHF2IEW { w: self }
|
|
}
|
|
#[doc = "Bit 12 - PLL out-of-lock interrupt enable"]
|
|
#[inline]
|
|
pub fn plloolie(&mut self) -> _PLLOOLIEW {
|
|
_PLLOOLIEW { w: self }
|
|
}
|
|
#[doc = "Bit 13 - PLL loss-of-signal interrupt enable"]
|
|
#[inline]
|
|
pub fn plllosie(&mut self) -> _PLLLOSIEW {
|
|
_PLLLOSIEW { w: self }
|
|
}
|
|
#[doc = "Bit 14 - PLL out-of-range interrupt enable"]
|
|
#[inline]
|
|
pub fn plloorie(&mut self) -> _PLLOORIEW {
|
|
_PLLOORIEW { w: self }
|
|
}
|
|
#[doc = "Bit 15 - REFCNT period counter interrupt enable"]
|
|
#[inline]
|
|
pub fn calie(&mut self) -> _CALIEW {
|
|
_CALIEW { w: self }
|
|
}
|
|
}
|