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