#[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::CR {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0x83
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = "Possible values of the field `HSION`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIONR {
#[doc = "Clock Off"]
OFF,
#[doc = "Clock On"]
ON,
}
impl HSIONR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
HSIONR::OFF => false,
HSIONR::ON => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> HSIONR {
match value {
false => HSIONR::OFF,
true => HSIONR::ON,
}
}
#[doc = "Checks if the value of the field is `OFF`"]
#[inline(always)]
pub fn is_off(&self) -> bool {
*self == HSIONR::OFF
}
#[doc = "Checks if the value of the field is `ON`"]
#[inline(always)]
pub fn is_on(&self) -> bool {
*self == HSIONR::ON
}
}
#[doc = "Values that can be written to the field `HSION`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIONW {
#[doc = "Clock Off"]
OFF,
#[doc = "Clock On"]
ON,
}
impl HSIONW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
HSIONW::OFF => false,
HSIONW::ON => true,
}
}
}
#[doc = r"Proxy"]
pub struct _HSIONW<'a> {
w: &'a mut W,
}
impl<'a> _HSIONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSIONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 0);
self.w.bits |= ((value as u32) & 0x01) << 0;
self.w
}
}
#[doc = "Possible values of the field `HSIKERON`"]
pub type HSIKERONR = HSIONR;
#[doc = "Values that can be written to the field `HSIKERON`"]
pub type HSIKERONW = HSIONW;
#[doc = r"Proxy"]
pub struct _HSIKERONW<'a> {
w: &'a mut W,
}
impl<'a> _HSIKERONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSIKERONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 1);
self.w.bits |= ((value as u32) & 0x01) << 1;
self.w
}
}
#[doc = "Possible values of the field `HSIRDY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIRDYR {
#[doc = "Clock not ready"]
NOTREADY,
#[doc = "Clock ready"]
READY,
}
impl HSIRDYR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
HSIRDYR::NOTREADY => false,
HSIRDYR::READY => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> HSIRDYR {
match value {
false => HSIRDYR::NOTREADY,
true => HSIRDYR::READY,
}
}
#[doc = "Checks if the value of the field is `NOTREADY`"]
#[inline(always)]
pub fn is_not_ready(&self) -> bool {
*self == HSIRDYR::NOTREADY
}
#[doc = "Checks if the value of the field is `READY`"]
#[inline(always)]
pub fn is_ready(&self) -> bool {
*self == HSIRDYR::READY
}
}
#[doc = "Values that can be written to the field `HSIRDY`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIRDYW {
#[doc = "Clock not ready"]
NOTREADY,
#[doc = "Clock ready"]
READY,
}
impl HSIRDYW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
HSIRDYW::NOTREADY => false,
HSIRDYW::READY => true,
}
}
}
#[doc = r"Proxy"]
pub struct _HSIRDYW<'a> {
w: &'a mut W,
}
impl<'a> _HSIRDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSIRDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 2);
self.w.bits |= ((value as u32) & 0x01) << 2;
self.w
}
}
#[doc = "Possible values of the field `HSIDIV`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIDIVR {
#[doc = "No division"]
DIV1,
#[doc = "Division by 2"]
DIV2,
#[doc = "Division by 4"]
DIV4,
#[doc = "Division by 8"]
DIV8,
}
impl HSIDIVR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
HSIDIVR::DIV1 => 0,
HSIDIVR::DIV2 => 0x01,
HSIDIVR::DIV4 => 0x02,
HSIDIVR::DIV8 => 0x03,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> HSIDIVR {
match value {
0 => HSIDIVR::DIV1,
1 => HSIDIVR::DIV2,
2 => HSIDIVR::DIV4,
3 => HSIDIVR::DIV8,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `DIV1`"]
#[inline(always)]
pub fn is_div1(&self) -> bool {
*self == HSIDIVR::DIV1
}
#[doc = "Checks if the value of the field is `DIV2`"]
#[inline(always)]
pub fn is_div2(&self) -> bool {
*self == HSIDIVR::DIV2
}
#[doc = "Checks if the value of the field is `DIV4`"]
#[inline(always)]
pub fn is_div4(&self) -> bool {
*self == HSIDIVR::DIV4
}
#[doc = "Checks if the value of the field is `DIV8`"]
#[inline(always)]
pub fn is_div8(&self) -> bool {
*self == HSIDIVR::DIV8
}
}
#[doc = "Values that can be written to the field `HSIDIV`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIDIVW {
#[doc = "No division"]
DIV1,
#[doc = "Division by 2"]
DIV2,
#[doc = "Division by 4"]
DIV4,
#[doc = "Division by 8"]
DIV8,
}
impl HSIDIVW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
HSIDIVW::DIV1 => 0,
HSIDIVW::DIV2 => 1,
HSIDIVW::DIV4 => 2,
HSIDIVW::DIV8 => 3,
}
}
}
#[doc = r"Proxy"]
pub struct _HSIDIVW<'a> {
w: &'a mut W,
}
impl<'a> _HSIDIVW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSIDIVW) -> &'a mut W {
{
self.bits(variant._bits())
}
}
#[doc = "No division"]
#[inline(always)]
pub fn div1(self) -> &'a mut W {
self.variant(HSIDIVW::DIV1)
}
#[doc = "Division by 2"]
#[inline(always)]
pub fn div2(self) -> &'a mut W {
self.variant(HSIDIVW::DIV2)
}
#[doc = "Division by 4"]
#[inline(always)]
pub fn div4(self) -> &'a mut W {
self.variant(HSIDIVW::DIV4)
}
#[doc = "Division by 8"]
#[inline(always)]
pub fn div8(self) -> &'a mut W {
self.variant(HSIDIVW::DIV8)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x03 << 3);
self.w.bits |= ((value as u32) & 0x03) << 3;
self.w
}
}
#[doc = "Possible values of the field `HSIDIVF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIDIVFR {
#[doc = "New HSIDIV ratio has not yet propagated to hsi_ck"]
NOTPROPAGATED,
#[doc = "HSIDIV ratio has propagated to hsi_ck"]
PROPAGATED,
}
impl HSIDIVFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
HSIDIVFR::NOTPROPAGATED => false,
HSIDIVFR::PROPAGATED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> HSIDIVFR {
match value {
false => HSIDIVFR::NOTPROPAGATED,
true => HSIDIVFR::PROPAGATED,
}
}
#[doc = "Checks if the value of the field is `NOTPROPAGATED`"]
#[inline(always)]
pub fn is_not_propagated(&self) -> bool {
*self == HSIDIVFR::NOTPROPAGATED
}
#[doc = "Checks if the value of the field is `PROPAGATED`"]
#[inline(always)]
pub fn is_propagated(&self) -> bool {
*self == HSIDIVFR::PROPAGATED
}
}
#[doc = "Values that can be written to the field `HSIDIVF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSIDIVFW {
#[doc = "New HSIDIV ratio has not yet propagated to hsi_ck"]
NOTPROPAGATED,
#[doc = "HSIDIV ratio has propagated to hsi_ck"]
PROPAGATED,
}
impl HSIDIVFW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
HSIDIVFW::NOTPROPAGATED => false,
HSIDIVFW::PROPAGATED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _HSIDIVFW<'a> {
w: &'a mut W,
}
impl<'a> _HSIDIVFW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSIDIVFW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "New HSIDIV ratio has not yet propagated to hsi_ck"]
#[inline(always)]
pub fn not_propagated(self) -> &'a mut W {
self.variant(HSIDIVFW::NOTPROPAGATED)
}
#[doc = "HSIDIV ratio has propagated to hsi_ck"]
#[inline(always)]
pub fn propagated(self) -> &'a mut W {
self.variant(HSIDIVFW::PROPAGATED)
}
#[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 &= !(0x01 << 5);
self.w.bits |= ((value as u32) & 0x01) << 5;
self.w
}
}
#[doc = "Possible values of the field `CSION`"]
pub type CSIONR = HSIONR;
#[doc = "Values that can be written to the field `CSION`"]
pub type CSIONW = HSIONW;
#[doc = r"Proxy"]
pub struct _CSIONW<'a> {
w: &'a mut W,
}
impl<'a> _CSIONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CSIONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 7);
self.w.bits |= ((value as u32) & 0x01) << 7;
self.w
}
}
#[doc = "Possible values of the field `CSIRDY`"]
pub type CSIRDYR = HSIRDYR;
#[doc = "Values that can be written to the field `CSIRDY`"]
pub type CSIRDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _CSIRDYW<'a> {
w: &'a mut W,
}
impl<'a> _CSIRDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CSIRDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 8);
self.w.bits |= ((value as u32) & 0x01) << 8;
self.w
}
}
#[doc = "Possible values of the field `CSIKERON`"]
pub type CSIKERONR = HSIONR;
#[doc = "Values that can be written to the field `CSIKERON`"]
pub type CSIKERONW = HSIONW;
#[doc = r"Proxy"]
pub struct _CSIKERONW<'a> {
w: &'a mut W,
}
impl<'a> _CSIKERONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: CSIKERONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 9);
self.w.bits |= ((value as u32) & 0x01) << 9;
self.w
}
}
#[doc = "Possible values of the field `HSI48ON`"]
pub type HSI48ONR = HSIONR;
#[doc = "Values that can be written to the field `HSI48ON`"]
pub type HSI48ONW = HSIONW;
#[doc = r"Proxy"]
pub struct _HSI48ONW<'a> {
w: &'a mut W,
}
impl<'a> _HSI48ONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSI48ONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 12);
self.w.bits |= ((value as u32) & 0x01) << 12;
self.w
}
}
#[doc = "Possible values of the field `HSI48RDY`"]
pub type HSI48RDYR = HSIRDYR;
#[doc = "Values that can be written to the field `HSI48RDY`"]
pub type HSI48RDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _HSI48RDYW<'a> {
w: &'a mut W,
}
impl<'a> _HSI48RDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSI48RDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 13);
self.w.bits |= ((value as u32) & 0x01) << 13;
self.w
}
}
#[doc = "Possible values of the field `D1CKRDY`"]
pub type D1CKRDYR = HSIRDYR;
#[doc = "Values that can be written to the field `D1CKRDY`"]
pub type D1CKRDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _D1CKRDYW<'a> {
w: &'a mut W,
}
impl<'a> _D1CKRDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: D1CKRDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 14);
self.w.bits |= ((value as u32) & 0x01) << 14;
self.w
}
}
#[doc = "Possible values of the field `D2CKRDY`"]
pub type D2CKRDYR = HSIRDYR;
#[doc = "Values that can be written to the field `D2CKRDY`"]
pub type D2CKRDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _D2CKRDYW<'a> {
w: &'a mut W,
}
impl<'a> _D2CKRDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: D2CKRDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 15);
self.w.bits |= ((value as u32) & 0x01) << 15;
self.w
}
}
#[doc = "Possible values of the field `HSEON`"]
pub type HSEONR = HSIONR;
#[doc = "Values that can be written to the field `HSEON`"]
pub type HSEONW = HSIONW;
#[doc = r"Proxy"]
pub struct _HSEONW<'a> {
w: &'a mut W,
}
impl<'a> _HSEONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSEONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 16);
self.w.bits |= ((value as u32) & 0x01) << 16;
self.w
}
}
#[doc = "Possible values of the field `HSERDY`"]
pub type HSERDYR = HSIRDYR;
#[doc = "Values that can be written to the field `HSERDY`"]
pub type HSERDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _HSERDYW<'a> {
w: &'a mut W,
}
impl<'a> _HSERDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSERDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 17);
self.w.bits |= ((value as u32) & 0x01) << 17;
self.w
}
}
#[doc = "Possible values of the field `HSEBYP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSEBYPR {
#[doc = "HSE crystal oscillator not bypassed"]
NOTBYPASSED,
#[doc = "HSE crystal oscillator bypassed with external clock"]
BYPASSED,
}
impl HSEBYPR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
HSEBYPR::NOTBYPASSED => false,
HSEBYPR::BYPASSED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> HSEBYPR {
match value {
false => HSEBYPR::NOTBYPASSED,
true => HSEBYPR::BYPASSED,
}
}
#[doc = "Checks if the value of the field is `NOTBYPASSED`"]
#[inline(always)]
pub fn is_not_bypassed(&self) -> bool {
*self == HSEBYPR::NOTBYPASSED
}
#[doc = "Checks if the value of the field is `BYPASSED`"]
#[inline(always)]
pub fn is_bypassed(&self) -> bool {
*self == HSEBYPR::BYPASSED
}
}
#[doc = "Values that can be written to the field `HSEBYP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum HSEBYPW {
#[doc = "HSE crystal oscillator not bypassed"]
NOTBYPASSED,
#[doc = "HSE crystal oscillator bypassed with external clock"]
BYPASSED,
}
impl HSEBYPW {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> bool {
match *self {
HSEBYPW::NOTBYPASSED => false,
HSEBYPW::BYPASSED => true,
}
}
}
#[doc = r"Proxy"]
pub struct _HSEBYPW<'a> {
w: &'a mut W,
}
impl<'a> _HSEBYPW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSEBYPW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "HSE crystal oscillator not bypassed"]
#[inline(always)]
pub fn not_bypassed(self) -> &'a mut W {
self.variant(HSEBYPW::NOTBYPASSED)
}
#[doc = "HSE crystal oscillator bypassed with external clock"]
#[inline(always)]
pub fn bypassed(self) -> &'a mut W {
self.variant(HSEBYPW::BYPASSED)
}
#[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 &= !(0x01 << 18);
self.w.bits |= ((value as u32) & 0x01) << 18;
self.w
}
}
#[doc = "Possible values of the field `HSECSSON`"]
pub type HSECSSONR = HSIONR;
#[doc = "Values that can be written to the field `HSECSSON`"]
pub type HSECSSONW = HSIONW;
#[doc = r"Proxy"]
pub struct _HSECSSONW<'a> {
w: &'a mut W,
}
impl<'a> _HSECSSONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: HSECSSONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 19);
self.w.bits |= ((value as u32) & 0x01) << 19;
self.w
}
}
#[doc = "Possible values of the field `PLL1ON`"]
pub type PLL1ONR = HSIONR;
#[doc = "Values that can be written to the field `PLL1ON`"]
pub type PLL1ONW = HSIONW;
#[doc = r"Proxy"]
pub struct _PLL1ONW<'a> {
w: &'a mut W,
}
impl<'a> _PLL1ONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL1ONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 24);
self.w.bits |= ((value as u32) & 0x01) << 24;
self.w
}
}
#[doc = "Possible values of the field `PLL1RDY`"]
pub type PLL1RDYR = HSIRDYR;
#[doc = "Values that can be written to the field `PLL1RDY`"]
pub type PLL1RDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _PLL1RDYW<'a> {
w: &'a mut W,
}
impl<'a> _PLL1RDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL1RDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 25);
self.w.bits |= ((value as u32) & 0x01) << 25;
self.w
}
}
#[doc = "Possible values of the field `PLL2ON`"]
pub type PLL2ONR = HSIONR;
#[doc = "Values that can be written to the field `PLL2ON`"]
pub type PLL2ONW = HSIONW;
#[doc = r"Proxy"]
pub struct _PLL2ONW<'a> {
w: &'a mut W,
}
impl<'a> _PLL2ONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL2ONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 26);
self.w.bits |= ((value as u32) & 0x01) << 26;
self.w
}
}
#[doc = "Possible values of the field `PLL2RDY`"]
pub type PLL2RDYR = HSIRDYR;
#[doc = "Values that can be written to the field `PLL2RDY`"]
pub type PLL2RDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _PLL2RDYW<'a> {
w: &'a mut W,
}
impl<'a> _PLL2RDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL2RDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 27);
self.w.bits |= ((value as u32) & 0x01) << 27;
self.w
}
}
#[doc = "Possible values of the field `PLL3ON`"]
pub type PLL3ONR = HSIONR;
#[doc = "Values that can be written to the field `PLL3ON`"]
pub type PLL3ONW = HSIONW;
#[doc = r"Proxy"]
pub struct _PLL3ONW<'a> {
w: &'a mut W,
}
impl<'a> _PLL3ONW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL3ONW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock Off"]
#[inline(always)]
pub fn off(self) -> &'a mut W {
self.variant(HSIONW::OFF)
}
#[doc = "Clock On"]
#[inline(always)]
pub fn on(self) -> &'a mut W {
self.variant(HSIONW::ON)
}
#[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 &= !(0x01 << 28);
self.w.bits |= ((value as u32) & 0x01) << 28;
self.w
}
}
#[doc = "Possible values of the field `PLL3RDY`"]
pub type PLL3RDYR = HSIRDYR;
#[doc = "Values that can be written to the field `PLL3RDY`"]
pub type PLL3RDYW = HSIRDYW;
#[doc = r"Proxy"]
pub struct _PLL3RDYW<'a> {
w: &'a mut W,
}
impl<'a> _PLL3RDYW<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: PLL3RDYW) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Clock not ready"]
#[inline(always)]
pub fn not_ready(self) -> &'a mut W {
self.variant(HSIRDYW::NOTREADY)
}
#[doc = "Clock ready"]
#[inline(always)]
pub fn ready(self) -> &'a mut W {
self.variant(HSIRDYW::READY)
}
#[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 &= !(0x01 << 29);
self.w.bits |= ((value as u32) & 0x01) << 29;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Internal high-speed clock enable"]
#[inline(always)]
pub fn hsion(&self) -> HSIONR {
HSIONR::_from(((self.bits >> 0) & 0x01) != 0)
}
#[doc = "Bit 1 - High Speed Internal clock enable in Stop mode"]
#[inline(always)]
pub fn hsikeron(&self) -> HSIKERONR {
HSIKERONR::_from(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - HSI clock ready flag"]
#[inline(always)]
pub fn hsirdy(&self) -> HSIRDYR {
HSIRDYR::_from(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bits 3:4 - HSI clock divider"]
#[inline(always)]
pub fn hsidiv(&self) -> HSIDIVR {
HSIDIVR::_from(((self.bits >> 3) & 0x03) as u8)
}
#[doc = "Bit 5 - HSI divider flag"]
#[inline(always)]
pub fn hsidivf(&self) -> HSIDIVFR {
HSIDIVFR::_from(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 7 - CSI clock enable"]
#[inline(always)]
pub fn csion(&self) -> CSIONR {
CSIONR::_from(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - CSI clock ready flag"]
#[inline(always)]
pub fn csirdy(&self) -> CSIRDYR {
CSIRDYR::_from(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - CSI clock enable in Stop mode"]
#[inline(always)]
pub fn csikeron(&self) -> CSIKERONR {
CSIKERONR::_from(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 12 - RC48 clock enable"]
#[inline(always)]
pub fn hsi48on(&self) -> HSI48ONR {
HSI48ONR::_from(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - RC48 clock ready flag"]
#[inline(always)]
pub fn hsi48rdy(&self) -> HSI48RDYR {
HSI48RDYR::_from(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - D1 domain clocks ready flag"]
#[inline(always)]
pub fn d1ckrdy(&self) -> D1CKRDYR {
D1CKRDYR::_from(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - D2 domain clocks ready flag"]
#[inline(always)]
pub fn d2ckrdy(&self) -> D2CKRDYR {
D2CKRDYR::_from(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - HSE clock enable"]
#[inline(always)]
pub fn hseon(&self) -> HSEONR {
HSEONR::_from(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 17 - HSE clock ready flag"]
#[inline(always)]
pub fn hserdy(&self) -> HSERDYR {
HSERDYR::_from(((self.bits >> 17) & 0x01) != 0)
}
#[doc = "Bit 18 - HSE clock bypass"]
#[inline(always)]
pub fn hsebyp(&self) -> HSEBYPR {
HSEBYPR::_from(((self.bits >> 18) & 0x01) != 0)
}
#[doc = "Bit 19 - HSE Clock Security System enable"]
#[inline(always)]
pub fn hsecsson(&self) -> HSECSSONR {
HSECSSONR::_from(((self.bits >> 19) & 0x01) != 0)
}
#[doc = "Bit 24 - PLL1 enable"]
#[inline(always)]
pub fn pll1on(&self) -> PLL1ONR {
PLL1ONR::_from(((self.bits >> 24) & 0x01) != 0)
}
#[doc = "Bit 25 - PLL1 clock ready flag"]
#[inline(always)]
pub fn pll1rdy(&self) -> PLL1RDYR {
PLL1RDYR::_from(((self.bits >> 25) & 0x01) != 0)
}
#[doc = "Bit 26 - PLL2 enable"]
#[inline(always)]
pub fn pll2on(&self) -> PLL2ONR {
PLL2ONR::_from(((self.bits >> 26) & 0x01) != 0)
}
#[doc = "Bit 27 - PLL2 clock ready flag"]
#[inline(always)]
pub fn pll2rdy(&self) -> PLL2RDYR {
PLL2RDYR::_from(((self.bits >> 27) & 0x01) != 0)
}
#[doc = "Bit 28 - PLL3 enable"]
#[inline(always)]
pub fn pll3on(&self) -> PLL3ONR {
PLL3ONR::_from(((self.bits >> 28) & 0x01) != 0)
}
#[doc = "Bit 29 - PLL3 clock ready flag"]
#[inline(always)]
pub fn pll3rdy(&self) -> PLL3RDYR {
PLL3RDYR::_from(((self.bits >> 29) & 0x01) != 0)
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - Internal high-speed clock enable"]
#[inline(always)]
pub fn hsion(&mut self) -> _HSIONW {
_HSIONW { w: self }
}
#[doc = "Bit 1 - High Speed Internal clock enable in Stop mode"]
#[inline(always)]
pub fn hsikeron(&mut self) -> _HSIKERONW {
_HSIKERONW { w: self }
}
#[doc = "Bit 2 - HSI clock ready flag"]
#[inline(always)]
pub fn hsirdy(&mut self) -> _HSIRDYW {
_HSIRDYW { w: self }
}
#[doc = "Bits 3:4 - HSI clock divider"]
#[inline(always)]
pub fn hsidiv(&mut self) -> _HSIDIVW {
_HSIDIVW { w: self }
}
#[doc = "Bit 5 - HSI divider flag"]
#[inline(always)]
pub fn hsidivf(&mut self) -> _HSIDIVFW {
_HSIDIVFW { w: self }
}
#[doc = "Bit 7 - CSI clock enable"]
#[inline(always)]
pub fn csion(&mut self) -> _CSIONW {
_CSIONW { w: self }
}
#[doc = "Bit 8 - CSI clock ready flag"]
#[inline(always)]
pub fn csirdy(&mut self) -> _CSIRDYW {
_CSIRDYW { w: self }
}
#[doc = "Bit 9 - CSI clock enable in Stop mode"]
#[inline(always)]
pub fn csikeron(&mut self) -> _CSIKERONW {
_CSIKERONW { w: self }
}
#[doc = "Bit 12 - RC48 clock enable"]
#[inline(always)]
pub fn hsi48on(&mut self) -> _HSI48ONW {
_HSI48ONW { w: self }
}
#[doc = "Bit 13 - RC48 clock ready flag"]
#[inline(always)]
pub fn hsi48rdy(&mut self) -> _HSI48RDYW {
_HSI48RDYW { w: self }
}
#[doc = "Bit 14 - D1 domain clocks ready flag"]
#[inline(always)]
pub fn d1ckrdy(&mut self) -> _D1CKRDYW {
_D1CKRDYW { w: self }
}
#[doc = "Bit 15 - D2 domain clocks ready flag"]
#[inline(always)]
pub fn d2ckrdy(&mut self) -> _D2CKRDYW {
_D2CKRDYW { w: self }
}
#[doc = "Bit 16 - HSE clock enable"]
#[inline(always)]
pub fn hseon(&mut self) -> _HSEONW {
_HSEONW { w: self }
}
#[doc = "Bit 17 - HSE clock ready flag"]
#[inline(always)]
pub fn hserdy(&mut self) -> _HSERDYW {
_HSERDYW { w: self }
}
#[doc = "Bit 18 - HSE clock bypass"]
#[inline(always)]
pub fn hsebyp(&mut self) -> _HSEBYPW {
_HSEBYPW { w: self }
}
#[doc = "Bit 19 - HSE Clock Security System enable"]
#[inline(always)]
pub fn hsecsson(&mut self) -> _HSECSSONW {
_HSECSSONW { w: self }
}
#[doc = "Bit 24 - PLL1 enable"]
#[inline(always)]
pub fn pll1on(&mut self) -> _PLL1ONW {
_PLL1ONW { w: self }
}
#[doc = "Bit 25 - PLL1 clock ready flag"]
#[inline(always)]
pub fn pll1rdy(&mut self) -> _PLL1RDYW {
_PLL1RDYW { w: self }
}
#[doc = "Bit 26 - PLL2 enable"]
#[inline(always)]
pub fn pll2on(&mut self) -> _PLL2ONW {
_PLL2ONW { w: self }
}
#[doc = "Bit 27 - PLL2 clock ready flag"]
#[inline(always)]
pub fn pll2rdy(&mut self) -> _PLL2RDYW {
_PLL2RDYW { w: self }
}
#[doc = "Bit 28 - PLL3 enable"]
#[inline(always)]
pub fn pll3on(&mut self) -> _PLL3ONW {
_PLL3ONW { w: self }
}
#[doc = "Bit 29 - PLL3 clock ready flag"]
#[inline(always)]
pub fn pll3rdy(&mut self) -> _PLL3RDYW {
_PLL3RDYW { w: self }
}
}