#[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::PLL1DIVR {
#[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 {
0x0101_0280
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = r"Value of the field"]
pub struct DIVN1R {
bits: u16,
}
impl DIVN1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u16 {
self.bits
}
}
#[doc = r"Proxy"]
pub struct _DIVN1W<'a> {
w: &'a mut W,
}
impl<'a> _DIVN1W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits &= !(0x01ff << 0);
self.w.bits |= ((value as u32) & 0x01ff) << 0;
self.w
}
}
#[doc = "Possible values of the field `DIVP1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DIVP1R {
#[doc = "pll_p_ck = vco_ck"]
DIV1,
#[doc = "pll_p_ck = vco_ck / 2"]
DIV2,
#[doc = "pll_p_ck = vco_ck / 4"]
DIV4,
#[doc = "pll_p_ck = vco_ck / 6"]
DIV6,
#[doc = "pll_p_ck = vco_ck / 8"]
DIV8,
#[doc = "pll_p_ck = vco_ck / 10"]
DIV10,
#[doc = "pll_p_ck = vco_ck / 12"]
DIV12,
#[doc = "pll_p_ck = vco_ck / 14"]
DIV14,
#[doc = "pll_p_ck = vco_ck / 16"]
DIV16,
#[doc = "pll_p_ck = vco_ck / 18"]
DIV18,
#[doc = "pll_p_ck = vco_ck / 20"]
DIV20,
#[doc = "pll_p_ck = vco_ck / 22"]
DIV22,
#[doc = "pll_p_ck = vco_ck / 24"]
DIV24,
#[doc = "pll_p_ck = vco_ck / 26"]
DIV26,
#[doc = "pll_p_ck = vco_ck / 28"]
DIV28,
#[doc = "pll_p_ck = vco_ck / 30"]
DIV30,
#[doc = "pll_p_ck = vco_ck / 32"]
DIV32,
#[doc = "pll_p_ck = vco_ck / 34"]
DIV34,
#[doc = "pll_p_ck = vco_ck / 36"]
DIV36,
#[doc = "pll_p_ck = vco_ck / 38"]
DIV38,
#[doc = "pll_p_ck = vco_ck / 40"]
DIV40,
#[doc = "pll_p_ck = vco_ck / 42"]
DIV42,
#[doc = "pll_p_ck = vco_ck / 44"]
DIV44,
#[doc = "pll_p_ck = vco_ck / 46"]
DIV46,
#[doc = "pll_p_ck = vco_ck / 48"]
DIV48,
#[doc = "pll_p_ck = vco_ck / 50"]
DIV50,
#[doc = "pll_p_ck = vco_ck / 52"]
DIV52,
#[doc = "pll_p_ck = vco_ck / 54"]
DIV54,
#[doc = "pll_p_ck = vco_ck / 56"]
DIV56,
#[doc = "pll_p_ck = vco_ck / 58"]
DIV58,
#[doc = "pll_p_ck = vco_ck / 60"]
DIV60,
#[doc = "pll_p_ck = vco_ck / 62"]
DIV62,
#[doc = "pll_p_ck = vco_ck / 64"]
DIV64,
#[doc = "pll_p_ck = vco_ck / 66"]
DIV66,
#[doc = "pll_p_ck = vco_ck / 68"]
DIV68,
#[doc = "pll_p_ck = vco_ck / 70"]
DIV70,
#[doc = "pll_p_ck = vco_ck / 72"]
DIV72,
#[doc = "pll_p_ck = vco_ck / 74"]
DIV74,
#[doc = "pll_p_ck = vco_ck / 76"]
DIV76,
#[doc = "pll_p_ck = vco_ck / 78"]
DIV78,
#[doc = "pll_p_ck = vco_ck / 80"]
DIV80,
#[doc = "pll_p_ck = vco_ck / 82"]
DIV82,
#[doc = "pll_p_ck = vco_ck / 84"]
DIV84,
#[doc = "pll_p_ck = vco_ck / 86"]
DIV86,
#[doc = "pll_p_ck = vco_ck / 88"]
DIV88,
#[doc = "pll_p_ck = vco_ck / 90"]
DIV90,
#[doc = "pll_p_ck = vco_ck / 92"]
DIV92,
#[doc = "pll_p_ck = vco_ck / 94"]
DIV94,
#[doc = "pll_p_ck = vco_ck / 96"]
DIV96,
#[doc = "pll_p_ck = vco_ck / 98"]
DIV98,
#[doc = "pll_p_ck = vco_ck / 100"]
DIV100,
#[doc = "pll_p_ck = vco_ck / 102"]
DIV102,
#[doc = "pll_p_ck = vco_ck / 104"]
DIV104,
#[doc = "pll_p_ck = vco_ck / 106"]
DIV106,
#[doc = "pll_p_ck = vco_ck / 108"]
DIV108,
#[doc = "pll_p_ck = vco_ck / 110"]
DIV110,
#[doc = "pll_p_ck = vco_ck / 112"]
DIV112,
#[doc = "pll_p_ck = vco_ck / 114"]
DIV114,
#[doc = "pll_p_ck = vco_ck / 116"]
DIV116,
#[doc = "pll_p_ck = vco_ck / 118"]
DIV118,
#[doc = "pll_p_ck = vco_ck / 120"]
DIV120,
#[doc = "pll_p_ck = vco_ck / 122"]
DIV122,
#[doc = "pll_p_ck = vco_ck / 124"]
DIV124,
#[doc = "pll_p_ck = vco_ck / 126"]
DIV126,
#[doc = "pll_p_ck = vco_ck / 128"]
DIV128,
#[doc = r"Reserved"]
_Reserved(u8),
}
impl DIVP1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
DIVP1R::DIV1 => 0,
DIVP1R::DIV2 => 0x01,
DIVP1R::DIV4 => 0x03,
DIVP1R::DIV6 => 0x05,
DIVP1R::DIV8 => 0x07,
DIVP1R::DIV10 => 0x09,
DIVP1R::DIV12 => 0x0b,
DIVP1R::DIV14 => 0x0d,
DIVP1R::DIV16 => 0x0f,
DIVP1R::DIV18 => 0x11,
DIVP1R::DIV20 => 0x13,
DIVP1R::DIV22 => 0x15,
DIVP1R::DIV24 => 0x17,
DIVP1R::DIV26 => 0x19,
DIVP1R::DIV28 => 0x1b,
DIVP1R::DIV30 => 0x1d,
DIVP1R::DIV32 => 0x1f,
DIVP1R::DIV34 => 0x21,
DIVP1R::DIV36 => 0x23,
DIVP1R::DIV38 => 0x25,
DIVP1R::DIV40 => 0x27,
DIVP1R::DIV42 => 0x29,
DIVP1R::DIV44 => 0x2b,
DIVP1R::DIV46 => 0x2d,
DIVP1R::DIV48 => 0x2f,
DIVP1R::DIV50 => 0x31,
DIVP1R::DIV52 => 0x33,
DIVP1R::DIV54 => 0x35,
DIVP1R::DIV56 => 0x37,
DIVP1R::DIV58 => 0x39,
DIVP1R::DIV60 => 0x3b,
DIVP1R::DIV62 => 0x3d,
DIVP1R::DIV64 => 0x3f,
DIVP1R::DIV66 => 0x41,
DIVP1R::DIV68 => 0x43,
DIVP1R::DIV70 => 0x45,
DIVP1R::DIV72 => 0x47,
DIVP1R::DIV74 => 0x49,
DIVP1R::DIV76 => 0x4b,
DIVP1R::DIV78 => 0x4d,
DIVP1R::DIV80 => 0x4f,
DIVP1R::DIV82 => 0x51,
DIVP1R::DIV84 => 0x53,
DIVP1R::DIV86 => 0x55,
DIVP1R::DIV88 => 0x57,
DIVP1R::DIV90 => 0x59,
DIVP1R::DIV92 => 0x5b,
DIVP1R::DIV94 => 0x5d,
DIVP1R::DIV96 => 0x5f,
DIVP1R::DIV98 => 0x61,
DIVP1R::DIV100 => 0x63,
DIVP1R::DIV102 => 0x65,
DIVP1R::DIV104 => 0x67,
DIVP1R::DIV106 => 0x69,
DIVP1R::DIV108 => 0x6b,
DIVP1R::DIV110 => 0x6d,
DIVP1R::DIV112 => 0x6f,
DIVP1R::DIV114 => 0x71,
DIVP1R::DIV116 => 0x73,
DIVP1R::DIV118 => 0x75,
DIVP1R::DIV120 => 0x77,
DIVP1R::DIV122 => 0x79,
DIVP1R::DIV124 => 0x7b,
DIVP1R::DIV126 => 0x7d,
DIVP1R::DIV128 => 0x7f,
DIVP1R::_Reserved(bits) => bits,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> DIVP1R {
match value {
0 => DIVP1R::DIV1,
1 => DIVP1R::DIV2,
3 => DIVP1R::DIV4,
5 => DIVP1R::DIV6,
7 => DIVP1R::DIV8,
9 => DIVP1R::DIV10,
11 => DIVP1R::DIV12,
13 => DIVP1R::DIV14,
15 => DIVP1R::DIV16,
17 => DIVP1R::DIV18,
19 => DIVP1R::DIV20,
21 => DIVP1R::DIV22,
23 => DIVP1R::DIV24,
25 => DIVP1R::DIV26,
27 => DIVP1R::DIV28,
29 => DIVP1R::DIV30,
31 => DIVP1R::DIV32,
33 => DIVP1R::DIV34,
35 => DIVP1R::DIV36,
37 => DIVP1R::DIV38,
39 => DIVP1R::DIV40,
41 => DIVP1R::DIV42,
43 => DIVP1R::DIV44,
45 => DIVP1R::DIV46,
47 => DIVP1R::DIV48,
49 => DIVP1R::DIV50,
51 => DIVP1R::DIV52,
53 => DIVP1R::DIV54,
55 => DIVP1R::DIV56,
57 => DIVP1R::DIV58,
59 => DIVP1R::DIV60,
61 => DIVP1R::DIV62,
63 => DIVP1R::DIV64,
65 => DIVP1R::DIV66,
67 => DIVP1R::DIV68,
69 => DIVP1R::DIV70,
71 => DIVP1R::DIV72,
73 => DIVP1R::DIV74,
75 => DIVP1R::DIV76,
77 => DIVP1R::DIV78,
79 => DIVP1R::DIV80,
81 => DIVP1R::DIV82,
83 => DIVP1R::DIV84,
85 => DIVP1R::DIV86,
87 => DIVP1R::DIV88,
89 => DIVP1R::DIV90,
91 => DIVP1R::DIV92,
93 => DIVP1R::DIV94,
95 => DIVP1R::DIV96,
97 => DIVP1R::DIV98,
99 => DIVP1R::DIV100,
101 => DIVP1R::DIV102,
103 => DIVP1R::DIV104,
105 => DIVP1R::DIV106,
107 => DIVP1R::DIV108,
109 => DIVP1R::DIV110,
111 => DIVP1R::DIV112,
113 => DIVP1R::DIV114,
115 => DIVP1R::DIV116,
117 => DIVP1R::DIV118,
119 => DIVP1R::DIV120,
121 => DIVP1R::DIV122,
123 => DIVP1R::DIV124,
125 => DIVP1R::DIV126,
127 => DIVP1R::DIV128,
i => DIVP1R::_Reserved(i),
}
}
#[doc = "Checks if the value of the field is `DIV1`"]
#[inline(always)]
pub fn is_div1(&self) -> bool {
*self == DIVP1R::DIV1
}
#[doc = "Checks if the value of the field is `DIV2`"]
#[inline(always)]
pub fn is_div2(&self) -> bool {
*self == DIVP1R::DIV2
}
#[doc = "Checks if the value of the field is `DIV4`"]
#[inline(always)]
pub fn is_div4(&self) -> bool {
*self == DIVP1R::DIV4
}
#[doc = "Checks if the value of the field is `DIV6`"]
#[inline(always)]
pub fn is_div6(&self) -> bool {
*self == DIVP1R::DIV6
}
#[doc = "Checks if the value of the field is `DIV8`"]
#[inline(always)]
pub fn is_div8(&self) -> bool {
*self == DIVP1R::DIV8
}
#[doc = "Checks if the value of the field is `DIV10`"]
#[inline(always)]
pub fn is_div10(&self) -> bool {
*self == DIVP1R::DIV10
}
#[doc = "Checks if the value of the field is `DIV12`"]
#[inline(always)]
pub fn is_div12(&self) -> bool {
*self == DIVP1R::DIV12
}
#[doc = "Checks if the value of the field is `DIV14`"]
#[inline(always)]
pub fn is_div14(&self) -> bool {
*self == DIVP1R::DIV14
}
#[doc = "Checks if the value of the field is `DIV16`"]
#[inline(always)]
pub fn is_div16(&self) -> bool {
*self == DIVP1R::DIV16
}
#[doc = "Checks if the value of the field is `DIV18`"]
#[inline(always)]
pub fn is_div18(&self) -> bool {
*self == DIVP1R::DIV18
}
#[doc = "Checks if the value of the field is `DIV20`"]
#[inline(always)]
pub fn is_div20(&self) -> bool {
*self == DIVP1R::DIV20
}
#[doc = "Checks if the value of the field is `DIV22`"]
#[inline(always)]
pub fn is_div22(&self) -> bool {
*self == DIVP1R::DIV22
}
#[doc = "Checks if the value of the field is `DIV24`"]
#[inline(always)]
pub fn is_div24(&self) -> bool {
*self == DIVP1R::DIV24
}
#[doc = "Checks if the value of the field is `DIV26`"]
#[inline(always)]
pub fn is_div26(&self) -> bool {
*self == DIVP1R::DIV26
}
#[doc = "Checks if the value of the field is `DIV28`"]
#[inline(always)]
pub fn is_div28(&self) -> bool {
*self == DIVP1R::DIV28
}
#[doc = "Checks if the value of the field is `DIV30`"]
#[inline(always)]
pub fn is_div30(&self) -> bool {
*self == DIVP1R::DIV30
}
#[doc = "Checks if the value of the field is `DIV32`"]
#[inline(always)]
pub fn is_div32(&self) -> bool {
*self == DIVP1R::DIV32
}
#[doc = "Checks if the value of the field is `DIV34`"]
#[inline(always)]
pub fn is_div34(&self) -> bool {
*self == DIVP1R::DIV34
}
#[doc = "Checks if the value of the field is `DIV36`"]
#[inline(always)]
pub fn is_div36(&self) -> bool {
*self == DIVP1R::DIV36
}
#[doc = "Checks if the value of the field is `DIV38`"]
#[inline(always)]
pub fn is_div38(&self) -> bool {
*self == DIVP1R::DIV38
}
#[doc = "Checks if the value of the field is `DIV40`"]
#[inline(always)]
pub fn is_div40(&self) -> bool {
*self == DIVP1R::DIV40
}
#[doc = "Checks if the value of the field is `DIV42`"]
#[inline(always)]
pub fn is_div42(&self) -> bool {
*self == DIVP1R::DIV42
}
#[doc = "Checks if the value of the field is `DIV44`"]
#[inline(always)]
pub fn is_div44(&self) -> bool {
*self == DIVP1R::DIV44
}
#[doc = "Checks if the value of the field is `DIV46`"]
#[inline(always)]
pub fn is_div46(&self) -> bool {
*self == DIVP1R::DIV46
}
#[doc = "Checks if the value of the field is `DIV48`"]
#[inline(always)]
pub fn is_div48(&self) -> bool {
*self == DIVP1R::DIV48
}
#[doc = "Checks if the value of the field is `DIV50`"]
#[inline(always)]
pub fn is_div50(&self) -> bool {
*self == DIVP1R::DIV50
}
#[doc = "Checks if the value of the field is `DIV52`"]
#[inline(always)]
pub fn is_div52(&self) -> bool {
*self == DIVP1R::DIV52
}
#[doc = "Checks if the value of the field is `DIV54`"]
#[inline(always)]
pub fn is_div54(&self) -> bool {
*self == DIVP1R::DIV54
}
#[doc = "Checks if the value of the field is `DIV56`"]
#[inline(always)]
pub fn is_div56(&self) -> bool {
*self == DIVP1R::DIV56
}
#[doc = "Checks if the value of the field is `DIV58`"]
#[inline(always)]
pub fn is_div58(&self) -> bool {
*self == DIVP1R::DIV58
}
#[doc = "Checks if the value of the field is `DIV60`"]
#[inline(always)]
pub fn is_div60(&self) -> bool {
*self == DIVP1R::DIV60
}
#[doc = "Checks if the value of the field is `DIV62`"]
#[inline(always)]
pub fn is_div62(&self) -> bool {
*self == DIVP1R::DIV62
}
#[doc = "Checks if the value of the field is `DIV64`"]
#[inline(always)]
pub fn is_div64(&self) -> bool {
*self == DIVP1R::DIV64
}
#[doc = "Checks if the value of the field is `DIV66`"]
#[inline(always)]
pub fn is_div66(&self) -> bool {
*self == DIVP1R::DIV66
}
#[doc = "Checks if the value of the field is `DIV68`"]
#[inline(always)]
pub fn is_div68(&self) -> bool {
*self == DIVP1R::DIV68
}
#[doc = "Checks if the value of the field is `DIV70`"]
#[inline(always)]
pub fn is_div70(&self) -> bool {
*self == DIVP1R::DIV70
}
#[doc = "Checks if the value of the field is `DIV72`"]
#[inline(always)]
pub fn is_div72(&self) -> bool {
*self == DIVP1R::DIV72
}
#[doc = "Checks if the value of the field is `DIV74`"]
#[inline(always)]
pub fn is_div74(&self) -> bool {
*self == DIVP1R::DIV74
}
#[doc = "Checks if the value of the field is `DIV76`"]
#[inline(always)]
pub fn is_div76(&self) -> bool {
*self == DIVP1R::DIV76
}
#[doc = "Checks if the value of the field is `DIV78`"]
#[inline(always)]
pub fn is_div78(&self) -> bool {
*self == DIVP1R::DIV78
}
#[doc = "Checks if the value of the field is `DIV80`"]
#[inline(always)]
pub fn is_div80(&self) -> bool {
*self == DIVP1R::DIV80
}
#[doc = "Checks if the value of the field is `DIV82`"]
#[inline(always)]
pub fn is_div82(&self) -> bool {
*self == DIVP1R::DIV82
}
#[doc = "Checks if the value of the field is `DIV84`"]
#[inline(always)]
pub fn is_div84(&self) -> bool {
*self == DIVP1R::DIV84
}
#[doc = "Checks if the value of the field is `DIV86`"]
#[inline(always)]
pub fn is_div86(&self) -> bool {
*self == DIVP1R::DIV86
}
#[doc = "Checks if the value of the field is `DIV88`"]
#[inline(always)]
pub fn is_div88(&self) -> bool {
*self == DIVP1R::DIV88
}
#[doc = "Checks if the value of the field is `DIV90`"]
#[inline(always)]
pub fn is_div90(&self) -> bool {
*self == DIVP1R::DIV90
}
#[doc = "Checks if the value of the field is `DIV92`"]
#[inline(always)]
pub fn is_div92(&self) -> bool {
*self == DIVP1R::DIV92
}
#[doc = "Checks if the value of the field is `DIV94`"]
#[inline(always)]
pub fn is_div94(&self) -> bool {
*self == DIVP1R::DIV94
}
#[doc = "Checks if the value of the field is `DIV96`"]
#[inline(always)]
pub fn is_div96(&self) -> bool {
*self == DIVP1R::DIV96
}
#[doc = "Checks if the value of the field is `DIV98`"]
#[inline(always)]
pub fn is_div98(&self) -> bool {
*self == DIVP1R::DIV98
}
#[doc = "Checks if the value of the field is `DIV100`"]
#[inline(always)]
pub fn is_div100(&self) -> bool {
*self == DIVP1R::DIV100
}
#[doc = "Checks if the value of the field is `DIV102`"]
#[inline(always)]
pub fn is_div102(&self) -> bool {
*self == DIVP1R::DIV102
}
#[doc = "Checks if the value of the field is `DIV104`"]
#[inline(always)]
pub fn is_div104(&self) -> bool {
*self == DIVP1R::DIV104
}
#[doc = "Checks if the value of the field is `DIV106`"]
#[inline(always)]
pub fn is_div106(&self) -> bool {
*self == DIVP1R::DIV106
}
#[doc = "Checks if the value of the field is `DIV108`"]
#[inline(always)]
pub fn is_div108(&self) -> bool {
*self == DIVP1R::DIV108
}
#[doc = "Checks if the value of the field is `DIV110`"]
#[inline(always)]
pub fn is_div110(&self) -> bool {
*self == DIVP1R::DIV110
}
#[doc = "Checks if the value of the field is `DIV112`"]
#[inline(always)]
pub fn is_div112(&self) -> bool {
*self == DIVP1R::DIV112
}
#[doc = "Checks if the value of the field is `DIV114`"]
#[inline(always)]
pub fn is_div114(&self) -> bool {
*self == DIVP1R::DIV114
}
#[doc = "Checks if the value of the field is `DIV116`"]
#[inline(always)]
pub fn is_div116(&self) -> bool {
*self == DIVP1R::DIV116
}
#[doc = "Checks if the value of the field is `DIV118`"]
#[inline(always)]
pub fn is_div118(&self) -> bool {
*self == DIVP1R::DIV118
}
#[doc = "Checks if the value of the field is `DIV120`"]
#[inline(always)]
pub fn is_div120(&self) -> bool {
*self == DIVP1R::DIV120
}
#[doc = "Checks if the value of the field is `DIV122`"]
#[inline(always)]
pub fn is_div122(&self) -> bool {
*self == DIVP1R::DIV122
}
#[doc = "Checks if the value of the field is `DIV124`"]
#[inline(always)]
pub fn is_div124(&self) -> bool {
*self == DIVP1R::DIV124
}
#[doc = "Checks if the value of the field is `DIV126`"]
#[inline(always)]
pub fn is_div126(&self) -> bool {
*self == DIVP1R::DIV126
}
#[doc = "Checks if the value of the field is `DIV128`"]
#[inline(always)]
pub fn is_div128(&self) -> bool {
*self == DIVP1R::DIV128
}
}
#[doc = "Values that can be written to the field `DIVP1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DIVP1W {
#[doc = "pll_p_ck = vco_ck"]
DIV1,
#[doc = "pll_p_ck = vco_ck / 2"]
DIV2,
#[doc = "pll_p_ck = vco_ck / 4"]
DIV4,
#[doc = "pll_p_ck = vco_ck / 6"]
DIV6,
#[doc = "pll_p_ck = vco_ck / 8"]
DIV8,
#[doc = "pll_p_ck = vco_ck / 10"]
DIV10,
#[doc = "pll_p_ck = vco_ck / 12"]
DIV12,
#[doc = "pll_p_ck = vco_ck / 14"]
DIV14,
#[doc = "pll_p_ck = vco_ck / 16"]
DIV16,
#[doc = "pll_p_ck = vco_ck / 18"]
DIV18,
#[doc = "pll_p_ck = vco_ck / 20"]
DIV20,
#[doc = "pll_p_ck = vco_ck / 22"]
DIV22,
#[doc = "pll_p_ck = vco_ck / 24"]
DIV24,
#[doc = "pll_p_ck = vco_ck / 26"]
DIV26,
#[doc = "pll_p_ck = vco_ck / 28"]
DIV28,
#[doc = "pll_p_ck = vco_ck / 30"]
DIV30,
#[doc = "pll_p_ck = vco_ck / 32"]
DIV32,
#[doc = "pll_p_ck = vco_ck / 34"]
DIV34,
#[doc = "pll_p_ck = vco_ck / 36"]
DIV36,
#[doc = "pll_p_ck = vco_ck / 38"]
DIV38,
#[doc = "pll_p_ck = vco_ck / 40"]
DIV40,
#[doc = "pll_p_ck = vco_ck / 42"]
DIV42,
#[doc = "pll_p_ck = vco_ck / 44"]
DIV44,
#[doc = "pll_p_ck = vco_ck / 46"]
DIV46,
#[doc = "pll_p_ck = vco_ck / 48"]
DIV48,
#[doc = "pll_p_ck = vco_ck / 50"]
DIV50,
#[doc = "pll_p_ck = vco_ck / 52"]
DIV52,
#[doc = "pll_p_ck = vco_ck / 54"]
DIV54,
#[doc = "pll_p_ck = vco_ck / 56"]
DIV56,
#[doc = "pll_p_ck = vco_ck / 58"]
DIV58,
#[doc = "pll_p_ck = vco_ck / 60"]
DIV60,
#[doc = "pll_p_ck = vco_ck / 62"]
DIV62,
#[doc = "pll_p_ck = vco_ck / 64"]
DIV64,
#[doc = "pll_p_ck = vco_ck / 66"]
DIV66,
#[doc = "pll_p_ck = vco_ck / 68"]
DIV68,
#[doc = "pll_p_ck = vco_ck / 70"]
DIV70,
#[doc = "pll_p_ck = vco_ck / 72"]
DIV72,
#[doc = "pll_p_ck = vco_ck / 74"]
DIV74,
#[doc = "pll_p_ck = vco_ck / 76"]
DIV76,
#[doc = "pll_p_ck = vco_ck / 78"]
DIV78,
#[doc = "pll_p_ck = vco_ck / 80"]
DIV80,
#[doc = "pll_p_ck = vco_ck / 82"]
DIV82,
#[doc = "pll_p_ck = vco_ck / 84"]
DIV84,
#[doc = "pll_p_ck = vco_ck / 86"]
DIV86,
#[doc = "pll_p_ck = vco_ck / 88"]
DIV88,
#[doc = "pll_p_ck = vco_ck / 90"]
DIV90,
#[doc = "pll_p_ck = vco_ck / 92"]
DIV92,
#[doc = "pll_p_ck = vco_ck / 94"]
DIV94,
#[doc = "pll_p_ck = vco_ck / 96"]
DIV96,
#[doc = "pll_p_ck = vco_ck / 98"]
DIV98,
#[doc = "pll_p_ck = vco_ck / 100"]
DIV100,
#[doc = "pll_p_ck = vco_ck / 102"]
DIV102,
#[doc = "pll_p_ck = vco_ck / 104"]
DIV104,
#[doc = "pll_p_ck = vco_ck / 106"]
DIV106,
#[doc = "pll_p_ck = vco_ck / 108"]
DIV108,
#[doc = "pll_p_ck = vco_ck / 110"]
DIV110,
#[doc = "pll_p_ck = vco_ck / 112"]
DIV112,
#[doc = "pll_p_ck = vco_ck / 114"]
DIV114,
#[doc = "pll_p_ck = vco_ck / 116"]
DIV116,
#[doc = "pll_p_ck = vco_ck / 118"]
DIV118,
#[doc = "pll_p_ck = vco_ck / 120"]
DIV120,
#[doc = "pll_p_ck = vco_ck / 122"]
DIV122,
#[doc = "pll_p_ck = vco_ck / 124"]
DIV124,
#[doc = "pll_p_ck = vco_ck / 126"]
DIV126,
#[doc = "pll_p_ck = vco_ck / 128"]
DIV128,
}
impl DIVP1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _bits(&self) -> u8 {
match *self {
DIVP1W::DIV1 => 0,
DIVP1W::DIV2 => 1,
DIVP1W::DIV4 => 3,
DIVP1W::DIV6 => 5,
DIVP1W::DIV8 => 7,
DIVP1W::DIV10 => 9,
DIVP1W::DIV12 => 11,
DIVP1W::DIV14 => 13,
DIVP1W::DIV16 => 15,
DIVP1W::DIV18 => 17,
DIVP1W::DIV20 => 19,
DIVP1W::DIV22 => 21,
DIVP1W::DIV24 => 23,
DIVP1W::DIV26 => 25,
DIVP1W::DIV28 => 27,
DIVP1W::DIV30 => 29,
DIVP1W::DIV32 => 31,
DIVP1W::DIV34 => 33,
DIVP1W::DIV36 => 35,
DIVP1W::DIV38 => 37,
DIVP1W::DIV40 => 39,
DIVP1W::DIV42 => 41,
DIVP1W::DIV44 => 43,
DIVP1W::DIV46 => 45,
DIVP1W::DIV48 => 47,
DIVP1W::DIV50 => 49,
DIVP1W::DIV52 => 51,
DIVP1W::DIV54 => 53,
DIVP1W::DIV56 => 55,
DIVP1W::DIV58 => 57,
DIVP1W::DIV60 => 59,
DIVP1W::DIV62 => 61,
DIVP1W::DIV64 => 63,
DIVP1W::DIV66 => 65,
DIVP1W::DIV68 => 67,
DIVP1W::DIV70 => 69,
DIVP1W::DIV72 => 71,
DIVP1W::DIV74 => 73,
DIVP1W::DIV76 => 75,
DIVP1W::DIV78 => 77,
DIVP1W::DIV80 => 79,
DIVP1W::DIV82 => 81,
DIVP1W::DIV84 => 83,
DIVP1W::DIV86 => 85,
DIVP1W::DIV88 => 87,
DIVP1W::DIV90 => 89,
DIVP1W::DIV92 => 91,
DIVP1W::DIV94 => 93,
DIVP1W::DIV96 => 95,
DIVP1W::DIV98 => 97,
DIVP1W::DIV100 => 99,
DIVP1W::DIV102 => 101,
DIVP1W::DIV104 => 103,
DIVP1W::DIV106 => 105,
DIVP1W::DIV108 => 107,
DIVP1W::DIV110 => 109,
DIVP1W::DIV112 => 111,
DIVP1W::DIV114 => 113,
DIVP1W::DIV116 => 115,
DIVP1W::DIV118 => 117,
DIVP1W::DIV120 => 119,
DIVP1W::DIV122 => 121,
DIVP1W::DIV124 => 123,
DIVP1W::DIV126 => 125,
DIVP1W::DIV128 => 127,
}
}
}
#[doc = r"Proxy"]
pub struct _DIVP1W<'a> {
w: &'a mut W,
}
impl<'a> _DIVP1W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: DIVP1W) -> &'a mut W {
unsafe { self.bits(variant._bits()) }
}
#[doc = "pll_p_ck = vco_ck"]
#[inline(always)]
pub fn div1(self) -> &'a mut W {
self.variant(DIVP1W::DIV1)
}
#[doc = "pll_p_ck = vco_ck / 2"]
#[inline(always)]
pub fn div2(self) -> &'a mut W {
self.variant(DIVP1W::DIV2)
}
#[doc = "pll_p_ck = vco_ck / 4"]
#[inline(always)]
pub fn div4(self) -> &'a mut W {
self.variant(DIVP1W::DIV4)
}
#[doc = "pll_p_ck = vco_ck / 6"]
#[inline(always)]
pub fn div6(self) -> &'a mut W {
self.variant(DIVP1W::DIV6)
}
#[doc = "pll_p_ck = vco_ck / 8"]
#[inline(always)]
pub fn div8(self) -> &'a mut W {
self.variant(DIVP1W::DIV8)
}
#[doc = "pll_p_ck = vco_ck / 10"]
#[inline(always)]
pub fn div10(self) -> &'a mut W {
self.variant(DIVP1W::DIV10)
}
#[doc = "pll_p_ck = vco_ck / 12"]
#[inline(always)]
pub fn div12(self) -> &'a mut W {
self.variant(DIVP1W::DIV12)
}
#[doc = "pll_p_ck = vco_ck / 14"]
#[inline(always)]
pub fn div14(self) -> &'a mut W {
self.variant(DIVP1W::DIV14)
}
#[doc = "pll_p_ck = vco_ck / 16"]
#[inline(always)]
pub fn div16(self) -> &'a mut W {
self.variant(DIVP1W::DIV16)
}
#[doc = "pll_p_ck = vco_ck / 18"]
#[inline(always)]
pub fn div18(self) -> &'a mut W {
self.variant(DIVP1W::DIV18)
}
#[doc = "pll_p_ck = vco_ck / 20"]
#[inline(always)]
pub fn div20(self) -> &'a mut W {
self.variant(DIVP1W::DIV20)
}
#[doc = "pll_p_ck = vco_ck / 22"]
#[inline(always)]
pub fn div22(self) -> &'a mut W {
self.variant(DIVP1W::DIV22)
}
#[doc = "pll_p_ck = vco_ck / 24"]
#[inline(always)]
pub fn div24(self) -> &'a mut W {
self.variant(DIVP1W::DIV24)
}
#[doc = "pll_p_ck = vco_ck / 26"]
#[inline(always)]
pub fn div26(self) -> &'a mut W {
self.variant(DIVP1W::DIV26)
}
#[doc = "pll_p_ck = vco_ck / 28"]
#[inline(always)]
pub fn div28(self) -> &'a mut W {
self.variant(DIVP1W::DIV28)
}
#[doc = "pll_p_ck = vco_ck / 30"]
#[inline(always)]
pub fn div30(self) -> &'a mut W {
self.variant(DIVP1W::DIV30)
}
#[doc = "pll_p_ck = vco_ck / 32"]
#[inline(always)]
pub fn div32(self) -> &'a mut W {
self.variant(DIVP1W::DIV32)
}
#[doc = "pll_p_ck = vco_ck / 34"]
#[inline(always)]
pub fn div34(self) -> &'a mut W {
self.variant(DIVP1W::DIV34)
}
#[doc = "pll_p_ck = vco_ck / 36"]
#[inline(always)]
pub fn div36(self) -> &'a mut W {
self.variant(DIVP1W::DIV36)
}
#[doc = "pll_p_ck = vco_ck / 38"]
#[inline(always)]
pub fn div38(self) -> &'a mut W {
self.variant(DIVP1W::DIV38)
}
#[doc = "pll_p_ck = vco_ck / 40"]
#[inline(always)]
pub fn div40(self) -> &'a mut W {
self.variant(DIVP1W::DIV40)
}
#[doc = "pll_p_ck = vco_ck / 42"]
#[inline(always)]
pub fn div42(self) -> &'a mut W {
self.variant(DIVP1W::DIV42)
}
#[doc = "pll_p_ck = vco_ck / 44"]
#[inline(always)]
pub fn div44(self) -> &'a mut W {
self.variant(DIVP1W::DIV44)
}
#[doc = "pll_p_ck = vco_ck / 46"]
#[inline(always)]
pub fn div46(self) -> &'a mut W {
self.variant(DIVP1W::DIV46)
}
#[doc = "pll_p_ck = vco_ck / 48"]
#[inline(always)]
pub fn div48(self) -> &'a mut W {
self.variant(DIVP1W::DIV48)
}
#[doc = "pll_p_ck = vco_ck / 50"]
#[inline(always)]
pub fn div50(self) -> &'a mut W {
self.variant(DIVP1W::DIV50)
}
#[doc = "pll_p_ck = vco_ck / 52"]
#[inline(always)]
pub fn div52(self) -> &'a mut W {
self.variant(DIVP1W::DIV52)
}
#[doc = "pll_p_ck = vco_ck / 54"]
#[inline(always)]
pub fn div54(self) -> &'a mut W {
self.variant(DIVP1W::DIV54)
}
#[doc = "pll_p_ck = vco_ck / 56"]
#[inline(always)]
pub fn div56(self) -> &'a mut W {
self.variant(DIVP1W::DIV56)
}
#[doc = "pll_p_ck = vco_ck / 58"]
#[inline(always)]
pub fn div58(self) -> &'a mut W {
self.variant(DIVP1W::DIV58)
}
#[doc = "pll_p_ck = vco_ck / 60"]
#[inline(always)]
pub fn div60(self) -> &'a mut W {
self.variant(DIVP1W::DIV60)
}
#[doc = "pll_p_ck = vco_ck / 62"]
#[inline(always)]
pub fn div62(self) -> &'a mut W {
self.variant(DIVP1W::DIV62)
}
#[doc = "pll_p_ck = vco_ck / 64"]
#[inline(always)]
pub fn div64(self) -> &'a mut W {
self.variant(DIVP1W::DIV64)
}
#[doc = "pll_p_ck = vco_ck / 66"]
#[inline(always)]
pub fn div66(self) -> &'a mut W {
self.variant(DIVP1W::DIV66)
}
#[doc = "pll_p_ck = vco_ck / 68"]
#[inline(always)]
pub fn div68(self) -> &'a mut W {
self.variant(DIVP1W::DIV68)
}
#[doc = "pll_p_ck = vco_ck / 70"]
#[inline(always)]
pub fn div70(self) -> &'a mut W {
self.variant(DIVP1W::DIV70)
}
#[doc = "pll_p_ck = vco_ck / 72"]
#[inline(always)]
pub fn div72(self) -> &'a mut W {
self.variant(DIVP1W::DIV72)
}
#[doc = "pll_p_ck = vco_ck / 74"]
#[inline(always)]
pub fn div74(self) -> &'a mut W {
self.variant(DIVP1W::DIV74)
}
#[doc = "pll_p_ck = vco_ck / 76"]
#[inline(always)]
pub fn div76(self) -> &'a mut W {
self.variant(DIVP1W::DIV76)
}
#[doc = "pll_p_ck = vco_ck / 78"]
#[inline(always)]
pub fn div78(self) -> &'a mut W {
self.variant(DIVP1W::DIV78)
}
#[doc = "pll_p_ck = vco_ck / 80"]
#[inline(always)]
pub fn div80(self) -> &'a mut W {
self.variant(DIVP1W::DIV80)
}
#[doc = "pll_p_ck = vco_ck / 82"]
#[inline(always)]
pub fn div82(self) -> &'a mut W {
self.variant(DIVP1W::DIV82)
}
#[doc = "pll_p_ck = vco_ck / 84"]
#[inline(always)]
pub fn div84(self) -> &'a mut W {
self.variant(DIVP1W::DIV84)
}
#[doc = "pll_p_ck = vco_ck / 86"]
#[inline(always)]
pub fn div86(self) -> &'a mut W {
self.variant(DIVP1W::DIV86)
}
#[doc = "pll_p_ck = vco_ck / 88"]
#[inline(always)]
pub fn div88(self) -> &'a mut W {
self.variant(DIVP1W::DIV88)
}
#[doc = "pll_p_ck = vco_ck / 90"]
#[inline(always)]
pub fn div90(self) -> &'a mut W {
self.variant(DIVP1W::DIV90)
}
#[doc = "pll_p_ck = vco_ck / 92"]
#[inline(always)]
pub fn div92(self) -> &'a mut W {
self.variant(DIVP1W::DIV92)
}
#[doc = "pll_p_ck = vco_ck / 94"]
#[inline(always)]
pub fn div94(self) -> &'a mut W {
self.variant(DIVP1W::DIV94)
}
#[doc = "pll_p_ck = vco_ck / 96"]
#[inline(always)]
pub fn div96(self) -> &'a mut W {
self.variant(DIVP1W::DIV96)
}
#[doc = "pll_p_ck = vco_ck / 98"]
#[inline(always)]
pub fn div98(self) -> &'a mut W {
self.variant(DIVP1W::DIV98)
}
#[doc = "pll_p_ck = vco_ck / 100"]
#[inline(always)]
pub fn div100(self) -> &'a mut W {
self.variant(DIVP1W::DIV100)
}
#[doc = "pll_p_ck = vco_ck / 102"]
#[inline(always)]
pub fn div102(self) -> &'a mut W {
self.variant(DIVP1W::DIV102)
}
#[doc = "pll_p_ck = vco_ck / 104"]
#[inline(always)]
pub fn div104(self) -> &'a mut W {
self.variant(DIVP1W::DIV104)
}
#[doc = "pll_p_ck = vco_ck / 106"]
#[inline(always)]
pub fn div106(self) -> &'a mut W {
self.variant(DIVP1W::DIV106)
}
#[doc = "pll_p_ck = vco_ck / 108"]
#[inline(always)]
pub fn div108(self) -> &'a mut W {
self.variant(DIVP1W::DIV108)
}
#[doc = "pll_p_ck = vco_ck / 110"]
#[inline(always)]
pub fn div110(self) -> &'a mut W {
self.variant(DIVP1W::DIV110)
}
#[doc = "pll_p_ck = vco_ck / 112"]
#[inline(always)]
pub fn div112(self) -> &'a mut W {
self.variant(DIVP1W::DIV112)
}
#[doc = "pll_p_ck = vco_ck / 114"]
#[inline(always)]
pub fn div114(self) -> &'a mut W {
self.variant(DIVP1W::DIV114)
}
#[doc = "pll_p_ck = vco_ck / 116"]
#[inline(always)]
pub fn div116(self) -> &'a mut W {
self.variant(DIVP1W::DIV116)
}
#[doc = "pll_p_ck = vco_ck / 118"]
#[inline(always)]
pub fn div118(self) -> &'a mut W {
self.variant(DIVP1W::DIV118)
}
#[doc = "pll_p_ck = vco_ck / 120"]
#[inline(always)]
pub fn div120(self) -> &'a mut W {
self.variant(DIVP1W::DIV120)
}
#[doc = "pll_p_ck = vco_ck / 122"]
#[inline(always)]
pub fn div122(self) -> &'a mut W {
self.variant(DIVP1W::DIV122)
}
#[doc = "pll_p_ck = vco_ck / 124"]
#[inline(always)]
pub fn div124(self) -> &'a mut W {
self.variant(DIVP1W::DIV124)
}
#[doc = "pll_p_ck = vco_ck / 126"]
#[inline(always)]
pub fn div126(self) -> &'a mut W {
self.variant(DIVP1W::DIV126)
}
#[doc = "pll_p_ck = vco_ck / 128"]
#[inline(always)]
pub fn div128(self) -> &'a mut W {
self.variant(DIVP1W::DIV128)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x7f << 9);
self.w.bits |= ((value as u32) & 0x7f) << 9;
self.w
}
}
#[doc = r"Value of the field"]
pub struct DIVQ1R {
bits: u8,
}
impl DIVQ1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
self.bits
}
}
#[doc = r"Proxy"]
pub struct _DIVQ1W<'a> {
w: &'a mut W,
}
impl<'a> _DIVQ1W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x7f << 16);
self.w.bits |= ((value as u32) & 0x7f) << 16;
self.w
}
}
#[doc = r"Value of the field"]
pub struct DIVR1R {
bits: u8,
}
impl DIVR1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
self.bits
}
}
#[doc = r"Proxy"]
pub struct _DIVR1W<'a> {
w: &'a mut W,
}
impl<'a> _DIVR1W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bits(self, value: u8) -> &'a mut W {
self.w.bits &= !(0x7f << 24);
self.w.bits |= ((value as u32) & 0x7f) << 24;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 0:8 - Multiplication factor for PLL1 VCO"]
#[inline(always)]
pub fn divn1(&self) -> DIVN1R {
let bits = ((self.bits >> 0) & 0x01ff) as u16;
DIVN1R { bits }
}
#[doc = "Bits 9:15 - PLL1 DIVP division factor"]
#[inline(always)]
pub fn divp1(&self) -> DIVP1R {
DIVP1R::_from(((self.bits >> 9) & 0x7f) as u8)
}
#[doc = "Bits 16:22 - PLL1 DIVQ division factor"]
#[inline(always)]
pub fn divq1(&self) -> DIVQ1R {
let bits = ((self.bits >> 16) & 0x7f) as u8;
DIVQ1R { bits }
}
#[doc = "Bits 24:30 - PLL1 DIVR division factor"]
#[inline(always)]
pub fn divr1(&self) -> DIVR1R {
let bits = ((self.bits >> 24) & 0x7f) as u8;
DIVR1R { bits }
}
}
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 = "Bits 0:8 - Multiplication factor for PLL1 VCO"]
#[inline(always)]
pub fn divn1(&mut self) -> _DIVN1W {
_DIVN1W { w: self }
}
#[doc = "Bits 9:15 - PLL1 DIVP division factor"]
#[inline(always)]
pub fn divp1(&mut self) -> _DIVP1W {
_DIVP1W { w: self }
}
#[doc = "Bits 16:22 - PLL1 DIVQ division factor"]
#[inline(always)]
pub fn divq1(&mut self) -> _DIVQ1W {
_DIVQ1W { w: self }
}
#[doc = "Bits 24:30 - PLL1 DIVR division factor"]
#[inline(always)]
pub fn divr1(&mut self) -> _DIVR1W {
_DIVR1W { w: self }
}
}