1#[doc = "Register `PDRUNCFG0` reader"]
2pub type R = crate::R<Pdruncfg0Spec>;
3#[doc = "Register `PDRUNCFG0` writer"]
4pub type W = crate::W<Pdruncfg0Spec>;
5#[doc = "no description available\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum PmicMode0 {
9 #[doc = "0: Set Mode0 to 0."]
10 SetMode0_0 = 0,
11 #[doc = "1: Set Mode0 to 1."]
12 SetMode0_1 = 1,
13}
14impl From<PmicMode0> for bool {
15 #[inline(always)]
16 fn from(variant: PmicMode0) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `PMIC_MODE0` reader - no description available"]
21pub type PmicMode0R = crate::BitReader<PmicMode0>;
22impl PmicMode0R {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> PmicMode0 {
26 match self.bits {
27 false => PmicMode0::SetMode0_0,
28 true => PmicMode0::SetMode0_1,
29 }
30 }
31 #[doc = "Set Mode0 to 0."]
32 #[inline(always)]
33 pub fn is_set_mode0_0(&self) -> bool {
34 *self == PmicMode0::SetMode0_0
35 }
36 #[doc = "Set Mode0 to 1."]
37 #[inline(always)]
38 pub fn is_set_mode0_1(&self) -> bool {
39 *self == PmicMode0::SetMode0_1
40 }
41}
42#[doc = "Field `PMIC_MODE0` writer - no description available"]
43pub type PmicMode0W<'a, REG> = crate::BitWriter<'a, REG, PmicMode0>;
44impl<'a, REG> PmicMode0W<'a, REG>
45where
46 REG: crate::Writable + crate::RegisterSpec,
47{
48 #[doc = "Set Mode0 to 0."]
49 #[inline(always)]
50 pub fn set_mode0_0(self) -> &'a mut crate::W<REG> {
51 self.variant(PmicMode0::SetMode0_0)
52 }
53 #[doc = "Set Mode0 to 1."]
54 #[inline(always)]
55 pub fn set_mode0_1(self) -> &'a mut crate::W<REG> {
56 self.variant(PmicMode0::SetMode0_1)
57 }
58}
59#[doc = "no description available\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum PmicMode1 {
63 #[doc = "0: Set Mode1 to 0."]
64 SetMode1_0 = 0,
65 #[doc = "1: Set Mode1 to 1."]
66 SetMode1_1 = 1,
67}
68impl From<PmicMode1> for bool {
69 #[inline(always)]
70 fn from(variant: PmicMode1) -> Self {
71 variant as u8 != 0
72 }
73}
74#[doc = "Field `PMIC_MODE1` reader - no description available"]
75pub type PmicMode1R = crate::BitReader<PmicMode1>;
76impl PmicMode1R {
77 #[doc = "Get enumerated values variant"]
78 #[inline(always)]
79 pub const fn variant(&self) -> PmicMode1 {
80 match self.bits {
81 false => PmicMode1::SetMode1_0,
82 true => PmicMode1::SetMode1_1,
83 }
84 }
85 #[doc = "Set Mode1 to 0."]
86 #[inline(always)]
87 pub fn is_set_mode1_0(&self) -> bool {
88 *self == PmicMode1::SetMode1_0
89 }
90 #[doc = "Set Mode1 to 1."]
91 #[inline(always)]
92 pub fn is_set_mode1_1(&self) -> bool {
93 *self == PmicMode1::SetMode1_1
94 }
95}
96#[doc = "Field `PMIC_MODE1` writer - no description available"]
97pub type PmicMode1W<'a, REG> = crate::BitWriter<'a, REG, PmicMode1>;
98impl<'a, REG> PmicMode1W<'a, REG>
99where
100 REG: crate::Writable + crate::RegisterSpec,
101{
102 #[doc = "Set Mode1 to 0."]
103 #[inline(always)]
104 pub fn set_mode1_0(self) -> &'a mut crate::W<REG> {
105 self.variant(PmicMode1::SetMode1_0)
106 }
107 #[doc = "Set Mode1 to 1."]
108 #[inline(always)]
109 pub fn set_mode1_1(self) -> &'a mut crate::W<REG> {
110 self.variant(PmicMode1::SetMode1_1)
111 }
112}
113#[doc = "no description available\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum VddcoreregLp {
117 #[doc = "0: VDDCOREREG HP Mode"]
118 HpMode = 0,
119 #[doc = "1: LP Mode"]
120 LpMode = 1,
121}
122impl From<VddcoreregLp> for bool {
123 #[inline(always)]
124 fn from(variant: VddcoreregLp) -> Self {
125 variant as u8 != 0
126 }
127}
128#[doc = "Field `VDDCOREREG_LP` reader - no description available"]
129pub type VddcoreregLpR = crate::BitReader<VddcoreregLp>;
130impl VddcoreregLpR {
131 #[doc = "Get enumerated values variant"]
132 #[inline(always)]
133 pub const fn variant(&self) -> VddcoreregLp {
134 match self.bits {
135 false => VddcoreregLp::HpMode,
136 true => VddcoreregLp::LpMode,
137 }
138 }
139 #[doc = "VDDCOREREG HP Mode"]
140 #[inline(always)]
141 pub fn is_hp_mode(&self) -> bool {
142 *self == VddcoreregLp::HpMode
143 }
144 #[doc = "LP Mode"]
145 #[inline(always)]
146 pub fn is_lp_mode(&self) -> bool {
147 *self == VddcoreregLp::LpMode
148 }
149}
150#[doc = "Field `VDDCOREREG_LP` writer - no description available"]
151pub type VddcoreregLpW<'a, REG> = crate::BitWriter<'a, REG, VddcoreregLp>;
152impl<'a, REG> VddcoreregLpW<'a, REG>
153where
154 REG: crate::Writable + crate::RegisterSpec,
155{
156 #[doc = "VDDCOREREG HP Mode"]
157 #[inline(always)]
158 pub fn hp_mode(self) -> &'a mut crate::W<REG> {
159 self.variant(VddcoreregLp::HpMode)
160 }
161 #[doc = "LP Mode"]
162 #[inline(always)]
163 pub fn lp_mode(self) -> &'a mut crate::W<REG> {
164 self.variant(VddcoreregLp::LpMode)
165 }
166}
167#[doc = "no description available\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum PmcrefLp {
171 #[doc = "0: PMCREF HP Mode"]
172 HpMode = 0,
173 #[doc = "1: PMCREF LP Mode"]
174 LpMode = 1,
175}
176impl From<PmcrefLp> for bool {
177 #[inline(always)]
178 fn from(variant: PmcrefLp) -> Self {
179 variant as u8 != 0
180 }
181}
182#[doc = "Field `PMCREF_LP` reader - no description available"]
183pub type PmcrefLpR = crate::BitReader<PmcrefLp>;
184impl PmcrefLpR {
185 #[doc = "Get enumerated values variant"]
186 #[inline(always)]
187 pub const fn variant(&self) -> PmcrefLp {
188 match self.bits {
189 false => PmcrefLp::HpMode,
190 true => PmcrefLp::LpMode,
191 }
192 }
193 #[doc = "PMCREF HP Mode"]
194 #[inline(always)]
195 pub fn is_hp_mode(&self) -> bool {
196 *self == PmcrefLp::HpMode
197 }
198 #[doc = "PMCREF LP Mode"]
199 #[inline(always)]
200 pub fn is_lp_mode(&self) -> bool {
201 *self == PmcrefLp::LpMode
202 }
203}
204#[doc = "Field `PMCREF_LP` writer - no description available"]
205pub type PmcrefLpW<'a, REG> = crate::BitWriter<'a, REG, PmcrefLp>;
206impl<'a, REG> PmcrefLpW<'a, REG>
207where
208 REG: crate::Writable + crate::RegisterSpec,
209{
210 #[doc = "PMCREF HP Mode"]
211 #[inline(always)]
212 pub fn hp_mode(self) -> &'a mut crate::W<REG> {
213 self.variant(PmcrefLp::HpMode)
214 }
215 #[doc = "PMCREF LP Mode"]
216 #[inline(always)]
217 pub fn lp_mode(self) -> &'a mut crate::W<REG> {
218 self.variant(PmcrefLp::LpMode)
219 }
220}
221#[doc = "no description available\n\nValue on reset: 1"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Hvd1v8Pd {
225 #[doc = "0: enabled"]
226 Enabled = 0,
227 #[doc = "1: power down"]
228 PowerDown = 1,
229}
230impl From<Hvd1v8Pd> for bool {
231 #[inline(always)]
232 fn from(variant: Hvd1v8Pd) -> Self {
233 variant as u8 != 0
234 }
235}
236#[doc = "Field `HVD1V8_PD` reader - no description available"]
237pub type Hvd1v8PdR = crate::BitReader<Hvd1v8Pd>;
238impl Hvd1v8PdR {
239 #[doc = "Get enumerated values variant"]
240 #[inline(always)]
241 pub const fn variant(&self) -> Hvd1v8Pd {
242 match self.bits {
243 false => Hvd1v8Pd::Enabled,
244 true => Hvd1v8Pd::PowerDown,
245 }
246 }
247 #[doc = "enabled"]
248 #[inline(always)]
249 pub fn is_enabled(&self) -> bool {
250 *self == Hvd1v8Pd::Enabled
251 }
252 #[doc = "power down"]
253 #[inline(always)]
254 pub fn is_power_down(&self) -> bool {
255 *self == Hvd1v8Pd::PowerDown
256 }
257}
258#[doc = "Field `HVD1V8_PD` writer - no description available"]
259pub type Hvd1v8PdW<'a, REG> = crate::BitWriter<'a, REG, Hvd1v8Pd>;
260impl<'a, REG> Hvd1v8PdW<'a, REG>
261where
262 REG: crate::Writable + crate::RegisterSpec,
263{
264 #[doc = "enabled"]
265 #[inline(always)]
266 pub fn enabled(self) -> &'a mut crate::W<REG> {
267 self.variant(Hvd1v8Pd::Enabled)
268 }
269 #[doc = "power down"]
270 #[inline(always)]
271 pub fn power_down(self) -> &'a mut crate::W<REG> {
272 self.variant(Hvd1v8Pd::PowerDown)
273 }
274}
275#[doc = "no description available\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum PorcoreLp {
279 #[doc = "0: LVD0V6 HP Mode"]
280 HpMode = 0,
281 #[doc = "1: LVD0V6 LP Mode"]
282 LpMode = 1,
283}
284impl From<PorcoreLp> for bool {
285 #[inline(always)]
286 fn from(variant: PorcoreLp) -> Self {
287 variant as u8 != 0
288 }
289}
290#[doc = "Field `PORCORE_LP` reader - no description available"]
291pub type PorcoreLpR = crate::BitReader<PorcoreLp>;
292impl PorcoreLpR {
293 #[doc = "Get enumerated values variant"]
294 #[inline(always)]
295 pub const fn variant(&self) -> PorcoreLp {
296 match self.bits {
297 false => PorcoreLp::HpMode,
298 true => PorcoreLp::LpMode,
299 }
300 }
301 #[doc = "LVD0V6 HP Mode"]
302 #[inline(always)]
303 pub fn is_hp_mode(&self) -> bool {
304 *self == PorcoreLp::HpMode
305 }
306 #[doc = "LVD0V6 LP Mode"]
307 #[inline(always)]
308 pub fn is_lp_mode(&self) -> bool {
309 *self == PorcoreLp::LpMode
310 }
311}
312#[doc = "Field `PORCORE_LP` writer - no description available"]
313pub type PorcoreLpW<'a, REG> = crate::BitWriter<'a, REG, PorcoreLp>;
314impl<'a, REG> PorcoreLpW<'a, REG>
315where
316 REG: crate::Writable + crate::RegisterSpec,
317{
318 #[doc = "LVD0V6 HP Mode"]
319 #[inline(always)]
320 pub fn hp_mode(self) -> &'a mut crate::W<REG> {
321 self.variant(PorcoreLp::HpMode)
322 }
323 #[doc = "LVD0V6 LP Mode"]
324 #[inline(always)]
325 pub fn lp_mode(self) -> &'a mut crate::W<REG> {
326 self.variant(PorcoreLp::LpMode)
327 }
328}
329#[doc = "no description available\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum LvdcoreLp {
333 #[doc = "0: LVD0V85 HP Mode"]
334 HpMode = 0,
335 #[doc = "1: LVD0V85 LP Mode."]
336 LpMode = 1,
337}
338impl From<LvdcoreLp> for bool {
339 #[inline(always)]
340 fn from(variant: LvdcoreLp) -> Self {
341 variant as u8 != 0
342 }
343}
344#[doc = "Field `LVDCORE_LP` reader - no description available"]
345pub type LvdcoreLpR = crate::BitReader<LvdcoreLp>;
346impl LvdcoreLpR {
347 #[doc = "Get enumerated values variant"]
348 #[inline(always)]
349 pub const fn variant(&self) -> LvdcoreLp {
350 match self.bits {
351 false => LvdcoreLp::HpMode,
352 true => LvdcoreLp::LpMode,
353 }
354 }
355 #[doc = "LVD0V85 HP Mode"]
356 #[inline(always)]
357 pub fn is_hp_mode(&self) -> bool {
358 *self == LvdcoreLp::HpMode
359 }
360 #[doc = "LVD0V85 LP Mode."]
361 #[inline(always)]
362 pub fn is_lp_mode(&self) -> bool {
363 *self == LvdcoreLp::LpMode
364 }
365}
366#[doc = "Field `LVDCORE_LP` writer - no description available"]
367pub type LvdcoreLpW<'a, REG> = crate::BitWriter<'a, REG, LvdcoreLp>;
368impl<'a, REG> LvdcoreLpW<'a, REG>
369where
370 REG: crate::Writable + crate::RegisterSpec,
371{
372 #[doc = "LVD0V85 HP Mode"]
373 #[inline(always)]
374 pub fn hp_mode(self) -> &'a mut crate::W<REG> {
375 self.variant(LvdcoreLp::HpMode)
376 }
377 #[doc = "LVD0V85 LP Mode."]
378 #[inline(always)]
379 pub fn lp_mode(self) -> &'a mut crate::W<REG> {
380 self.variant(LvdcoreLp::LpMode)
381 }
382}
383#[doc = "no description available\n\nValue on reset: 1"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum HvdcorePd {
387 #[doc = "0: enabled"]
388 Enabled = 0,
389 #[doc = "1: power down"]
390 PowerDown = 1,
391}
392impl From<HvdcorePd> for bool {
393 #[inline(always)]
394 fn from(variant: HvdcorePd) -> Self {
395 variant as u8 != 0
396 }
397}
398#[doc = "Field `HVDCORE_PD` reader - no description available"]
399pub type HvdcorePdR = crate::BitReader<HvdcorePd>;
400impl HvdcorePdR {
401 #[doc = "Get enumerated values variant"]
402 #[inline(always)]
403 pub const fn variant(&self) -> HvdcorePd {
404 match self.bits {
405 false => HvdcorePd::Enabled,
406 true => HvdcorePd::PowerDown,
407 }
408 }
409 #[doc = "enabled"]
410 #[inline(always)]
411 pub fn is_enabled(&self) -> bool {
412 *self == HvdcorePd::Enabled
413 }
414 #[doc = "power down"]
415 #[inline(always)]
416 pub fn is_power_down(&self) -> bool {
417 *self == HvdcorePd::PowerDown
418 }
419}
420#[doc = "Field `HVDCORE_PD` writer - no description available"]
421pub type HvdcorePdW<'a, REG> = crate::BitWriter<'a, REG, HvdcorePd>;
422impl<'a, REG> HvdcorePdW<'a, REG>
423where
424 REG: crate::Writable + crate::RegisterSpec,
425{
426 #[doc = "enabled"]
427 #[inline(always)]
428 pub fn enabled(self) -> &'a mut crate::W<REG> {
429 self.variant(HvdcorePd::Enabled)
430 }
431 #[doc = "power down"]
432 #[inline(always)]
433 pub fn power_down(self) -> &'a mut crate::W<REG> {
434 self.variant(HvdcorePd::PowerDown)
435 }
436}
437#[doc = "no description available\n\nValue on reset: 1"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum SysxtalPd {
441 #[doc = "0: enabled"]
442 Enabled = 0,
443 #[doc = "1: power down"]
444 PowerDown = 1,
445}
446impl From<SysxtalPd> for bool {
447 #[inline(always)]
448 fn from(variant: SysxtalPd) -> Self {
449 variant as u8 != 0
450 }
451}
452#[doc = "Field `SYSXTAL_PD` reader - no description available"]
453pub type SysxtalPdR = crate::BitReader<SysxtalPd>;
454impl SysxtalPdR {
455 #[doc = "Get enumerated values variant"]
456 #[inline(always)]
457 pub const fn variant(&self) -> SysxtalPd {
458 match self.bits {
459 false => SysxtalPd::Enabled,
460 true => SysxtalPd::PowerDown,
461 }
462 }
463 #[doc = "enabled"]
464 #[inline(always)]
465 pub fn is_enabled(&self) -> bool {
466 *self == SysxtalPd::Enabled
467 }
468 #[doc = "power down"]
469 #[inline(always)]
470 pub fn is_power_down(&self) -> bool {
471 *self == SysxtalPd::PowerDown
472 }
473}
474#[doc = "Field `SYSXTAL_PD` writer - no description available"]
475pub type SysxtalPdW<'a, REG> = crate::BitWriter<'a, REG, SysxtalPd>;
476impl<'a, REG> SysxtalPdW<'a, REG>
477where
478 REG: crate::Writable + crate::RegisterSpec,
479{
480 #[doc = "enabled"]
481 #[inline(always)]
482 pub fn enabled(self) -> &'a mut crate::W<REG> {
483 self.variant(SysxtalPd::Enabled)
484 }
485 #[doc = "power down"]
486 #[inline(always)]
487 pub fn power_down(self) -> &'a mut crate::W<REG> {
488 self.variant(SysxtalPd::PowerDown)
489 }
490}
491#[doc = "no description available\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum LposcPd {
495 #[doc = "0: enabled"]
496 Enabled = 0,
497 #[doc = "1: power down"]
498 PowerDown = 1,
499}
500impl From<LposcPd> for bool {
501 #[inline(always)]
502 fn from(variant: LposcPd) -> Self {
503 variant as u8 != 0
504 }
505}
506#[doc = "Field `LPOSC_PD` reader - no description available"]
507pub type LposcPdR = crate::BitReader<LposcPd>;
508impl LposcPdR {
509 #[doc = "Get enumerated values variant"]
510 #[inline(always)]
511 pub const fn variant(&self) -> LposcPd {
512 match self.bits {
513 false => LposcPd::Enabled,
514 true => LposcPd::PowerDown,
515 }
516 }
517 #[doc = "enabled"]
518 #[inline(always)]
519 pub fn is_enabled(&self) -> bool {
520 *self == LposcPd::Enabled
521 }
522 #[doc = "power down"]
523 #[inline(always)]
524 pub fn is_power_down(&self) -> bool {
525 *self == LposcPd::PowerDown
526 }
527}
528#[doc = "Field `LPOSC_PD` writer - no description available"]
529pub type LposcPdW<'a, REG> = crate::BitWriter<'a, REG, LposcPd>;
530impl<'a, REG> LposcPdW<'a, REG>
531where
532 REG: crate::Writable + crate::RegisterSpec,
533{
534 #[doc = "enabled"]
535 #[inline(always)]
536 pub fn enabled(self) -> &'a mut crate::W<REG> {
537 self.variant(LposcPd::Enabled)
538 }
539 #[doc = "power down"]
540 #[inline(always)]
541 pub fn power_down(self) -> &'a mut crate::W<REG> {
542 self.variant(LposcPd::PowerDown)
543 }
544}
545#[doc = "no description available\n\nValue on reset: 1"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum SfroPd {
549 #[doc = "0: enabled"]
550 Enabled = 0,
551 #[doc = "1: power down"]
552 PowerDown = 1,
553}
554impl From<SfroPd> for bool {
555 #[inline(always)]
556 fn from(variant: SfroPd) -> Self {
557 variant as u8 != 0
558 }
559}
560#[doc = "Field `SFRO_PD` reader - no description available"]
561pub type SfroPdR = crate::BitReader<SfroPd>;
562impl SfroPdR {
563 #[doc = "Get enumerated values variant"]
564 #[inline(always)]
565 pub const fn variant(&self) -> SfroPd {
566 match self.bits {
567 false => SfroPd::Enabled,
568 true => SfroPd::PowerDown,
569 }
570 }
571 #[doc = "enabled"]
572 #[inline(always)]
573 pub fn is_enabled(&self) -> bool {
574 *self == SfroPd::Enabled
575 }
576 #[doc = "power down"]
577 #[inline(always)]
578 pub fn is_power_down(&self) -> bool {
579 *self == SfroPd::PowerDown
580 }
581}
582#[doc = "Field `SFRO_PD` writer - no description available"]
583pub type SfroPdW<'a, REG> = crate::BitWriter<'a, REG, SfroPd>;
584impl<'a, REG> SfroPdW<'a, REG>
585where
586 REG: crate::Writable + crate::RegisterSpec,
587{
588 #[doc = "enabled"]
589 #[inline(always)]
590 pub fn enabled(self) -> &'a mut crate::W<REG> {
591 self.variant(SfroPd::Enabled)
592 }
593 #[doc = "power down"]
594 #[inline(always)]
595 pub fn power_down(self) -> &'a mut crate::W<REG> {
596 self.variant(SfroPd::PowerDown)
597 }
598}
599#[doc = "no description available\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum FfroPd {
603 #[doc = "0: enabled"]
604 Enabled = 0,
605 #[doc = "1: power down"]
606 PowerDown = 1,
607}
608impl From<FfroPd> for bool {
609 #[inline(always)]
610 fn from(variant: FfroPd) -> Self {
611 variant as u8 != 0
612 }
613}
614#[doc = "Field `FFRO_PD` reader - no description available"]
615pub type FfroPdR = crate::BitReader<FfroPd>;
616impl FfroPdR {
617 #[doc = "Get enumerated values variant"]
618 #[inline(always)]
619 pub const fn variant(&self) -> FfroPd {
620 match self.bits {
621 false => FfroPd::Enabled,
622 true => FfroPd::PowerDown,
623 }
624 }
625 #[doc = "enabled"]
626 #[inline(always)]
627 pub fn is_enabled(&self) -> bool {
628 *self == FfroPd::Enabled
629 }
630 #[doc = "power down"]
631 #[inline(always)]
632 pub fn is_power_down(&self) -> bool {
633 *self == FfroPd::PowerDown
634 }
635}
636#[doc = "Field `FFRO_PD` writer - no description available"]
637pub type FfroPdW<'a, REG> = crate::BitWriter<'a, REG, FfroPd>;
638impl<'a, REG> FfroPdW<'a, REG>
639where
640 REG: crate::Writable + crate::RegisterSpec,
641{
642 #[doc = "enabled"]
643 #[inline(always)]
644 pub fn enabled(self) -> &'a mut crate::W<REG> {
645 self.variant(FfroPd::Enabled)
646 }
647 #[doc = "power down"]
648 #[inline(always)]
649 pub fn power_down(self) -> &'a mut crate::W<REG> {
650 self.variant(FfroPd::PowerDown)
651 }
652}
653#[doc = "no description available\n\nValue on reset: 1"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum SyspllldoPd {
657 #[doc = "0: enabled"]
658 Enabled = 0,
659 #[doc = "1: power down"]
660 PowerDown = 1,
661}
662impl From<SyspllldoPd> for bool {
663 #[inline(always)]
664 fn from(variant: SyspllldoPd) -> Self {
665 variant as u8 != 0
666 }
667}
668#[doc = "Field `SYSPLLLDO_PD` reader - no description available"]
669pub type SyspllldoPdR = crate::BitReader<SyspllldoPd>;
670impl SyspllldoPdR {
671 #[doc = "Get enumerated values variant"]
672 #[inline(always)]
673 pub const fn variant(&self) -> SyspllldoPd {
674 match self.bits {
675 false => SyspllldoPd::Enabled,
676 true => SyspllldoPd::PowerDown,
677 }
678 }
679 #[doc = "enabled"]
680 #[inline(always)]
681 pub fn is_enabled(&self) -> bool {
682 *self == SyspllldoPd::Enabled
683 }
684 #[doc = "power down"]
685 #[inline(always)]
686 pub fn is_power_down(&self) -> bool {
687 *self == SyspllldoPd::PowerDown
688 }
689}
690#[doc = "Field `SYSPLLLDO_PD` writer - no description available"]
691pub type SyspllldoPdW<'a, REG> = crate::BitWriter<'a, REG, SyspllldoPd>;
692impl<'a, REG> SyspllldoPdW<'a, REG>
693where
694 REG: crate::Writable + crate::RegisterSpec,
695{
696 #[doc = "enabled"]
697 #[inline(always)]
698 pub fn enabled(self) -> &'a mut crate::W<REG> {
699 self.variant(SyspllldoPd::Enabled)
700 }
701 #[doc = "power down"]
702 #[inline(always)]
703 pub fn power_down(self) -> &'a mut crate::W<REG> {
704 self.variant(SyspllldoPd::PowerDown)
705 }
706}
707#[doc = "no description available\n\nValue on reset: 1"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum SyspllanaPd {
711 #[doc = "0: enabled"]
712 Enabled = 0,
713 #[doc = "1: power down"]
714 PowerDown = 1,
715}
716impl From<SyspllanaPd> for bool {
717 #[inline(always)]
718 fn from(variant: SyspllanaPd) -> Self {
719 variant as u8 != 0
720 }
721}
722#[doc = "Field `SYSPLLANA_PD` reader - no description available"]
723pub type SyspllanaPdR = crate::BitReader<SyspllanaPd>;
724impl SyspllanaPdR {
725 #[doc = "Get enumerated values variant"]
726 #[inline(always)]
727 pub const fn variant(&self) -> SyspllanaPd {
728 match self.bits {
729 false => SyspllanaPd::Enabled,
730 true => SyspllanaPd::PowerDown,
731 }
732 }
733 #[doc = "enabled"]
734 #[inline(always)]
735 pub fn is_enabled(&self) -> bool {
736 *self == SyspllanaPd::Enabled
737 }
738 #[doc = "power down"]
739 #[inline(always)]
740 pub fn is_power_down(&self) -> bool {
741 *self == SyspllanaPd::PowerDown
742 }
743}
744#[doc = "Field `SYSPLLANA_PD` writer - no description available"]
745pub type SyspllanaPdW<'a, REG> = crate::BitWriter<'a, REG, SyspllanaPd>;
746impl<'a, REG> SyspllanaPdW<'a, REG>
747where
748 REG: crate::Writable + crate::RegisterSpec,
749{
750 #[doc = "enabled"]
751 #[inline(always)]
752 pub fn enabled(self) -> &'a mut crate::W<REG> {
753 self.variant(SyspllanaPd::Enabled)
754 }
755 #[doc = "power down"]
756 #[inline(always)]
757 pub fn power_down(self) -> &'a mut crate::W<REG> {
758 self.variant(SyspllanaPd::PowerDown)
759 }
760}
761#[doc = "no description available\n\nValue on reset: 1"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum AudpllldoPd {
765 #[doc = "0: enabled"]
766 Enabled = 0,
767 #[doc = "1: power down"]
768 PowerDown = 1,
769}
770impl From<AudpllldoPd> for bool {
771 #[inline(always)]
772 fn from(variant: AudpllldoPd) -> Self {
773 variant as u8 != 0
774 }
775}
776#[doc = "Field `AUDPLLLDO_PD` reader - no description available"]
777pub type AudpllldoPdR = crate::BitReader<AudpllldoPd>;
778impl AudpllldoPdR {
779 #[doc = "Get enumerated values variant"]
780 #[inline(always)]
781 pub const fn variant(&self) -> AudpllldoPd {
782 match self.bits {
783 false => AudpllldoPd::Enabled,
784 true => AudpllldoPd::PowerDown,
785 }
786 }
787 #[doc = "enabled"]
788 #[inline(always)]
789 pub fn is_enabled(&self) -> bool {
790 *self == AudpllldoPd::Enabled
791 }
792 #[doc = "power down"]
793 #[inline(always)]
794 pub fn is_power_down(&self) -> bool {
795 *self == AudpllldoPd::PowerDown
796 }
797}
798#[doc = "Field `AUDPLLLDO_PD` writer - no description available"]
799pub type AudpllldoPdW<'a, REG> = crate::BitWriter<'a, REG, AudpllldoPd>;
800impl<'a, REG> AudpllldoPdW<'a, REG>
801where
802 REG: crate::Writable + crate::RegisterSpec,
803{
804 #[doc = "enabled"]
805 #[inline(always)]
806 pub fn enabled(self) -> &'a mut crate::W<REG> {
807 self.variant(AudpllldoPd::Enabled)
808 }
809 #[doc = "power down"]
810 #[inline(always)]
811 pub fn power_down(self) -> &'a mut crate::W<REG> {
812 self.variant(AudpllldoPd::PowerDown)
813 }
814}
815#[doc = "no description available\n\nValue on reset: 1"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum AudpllanaPd {
819 #[doc = "0: enabled"]
820 Enabled = 0,
821 #[doc = "1: power down"]
822 PowerDown = 1,
823}
824impl From<AudpllanaPd> for bool {
825 #[inline(always)]
826 fn from(variant: AudpllanaPd) -> Self {
827 variant as u8 != 0
828 }
829}
830#[doc = "Field `AUDPLLANA_PD` reader - no description available"]
831pub type AudpllanaPdR = crate::BitReader<AudpllanaPd>;
832impl AudpllanaPdR {
833 #[doc = "Get enumerated values variant"]
834 #[inline(always)]
835 pub const fn variant(&self) -> AudpllanaPd {
836 match self.bits {
837 false => AudpllanaPd::Enabled,
838 true => AudpllanaPd::PowerDown,
839 }
840 }
841 #[doc = "enabled"]
842 #[inline(always)]
843 pub fn is_enabled(&self) -> bool {
844 *self == AudpllanaPd::Enabled
845 }
846 #[doc = "power down"]
847 #[inline(always)]
848 pub fn is_power_down(&self) -> bool {
849 *self == AudpllanaPd::PowerDown
850 }
851}
852#[doc = "Field `AUDPLLANA_PD` writer - no description available"]
853pub type AudpllanaPdW<'a, REG> = crate::BitWriter<'a, REG, AudpllanaPd>;
854impl<'a, REG> AudpllanaPdW<'a, REG>
855where
856 REG: crate::Writable + crate::RegisterSpec,
857{
858 #[doc = "enabled"]
859 #[inline(always)]
860 pub fn enabled(self) -> &'a mut crate::W<REG> {
861 self.variant(AudpllanaPd::Enabled)
862 }
863 #[doc = "power down"]
864 #[inline(always)]
865 pub fn power_down(self) -> &'a mut crate::W<REG> {
866 self.variant(AudpllanaPd::PowerDown)
867 }
868}
869#[doc = "no description available\n\nValue on reset: 1"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum AdcPd {
873 #[doc = "0: enabled"]
874 Enabled = 0,
875 #[doc = "1: power down"]
876 PowerDown = 1,
877}
878impl From<AdcPd> for bool {
879 #[inline(always)]
880 fn from(variant: AdcPd) -> Self {
881 variant as u8 != 0
882 }
883}
884#[doc = "Field `ADC_PD` reader - no description available"]
885pub type AdcPdR = crate::BitReader<AdcPd>;
886impl AdcPdR {
887 #[doc = "Get enumerated values variant"]
888 #[inline(always)]
889 pub const fn variant(&self) -> AdcPd {
890 match self.bits {
891 false => AdcPd::Enabled,
892 true => AdcPd::PowerDown,
893 }
894 }
895 #[doc = "enabled"]
896 #[inline(always)]
897 pub fn is_enabled(&self) -> bool {
898 *self == AdcPd::Enabled
899 }
900 #[doc = "power down"]
901 #[inline(always)]
902 pub fn is_power_down(&self) -> bool {
903 *self == AdcPd::PowerDown
904 }
905}
906#[doc = "Field `ADC_PD` writer - no description available"]
907pub type AdcPdW<'a, REG> = crate::BitWriter<'a, REG, AdcPd>;
908impl<'a, REG> AdcPdW<'a, REG>
909where
910 REG: crate::Writable + crate::RegisterSpec,
911{
912 #[doc = "enabled"]
913 #[inline(always)]
914 pub fn enabled(self) -> &'a mut crate::W<REG> {
915 self.variant(AdcPd::Enabled)
916 }
917 #[doc = "power down"]
918 #[inline(always)]
919 pub fn power_down(self) -> &'a mut crate::W<REG> {
920 self.variant(AdcPd::PowerDown)
921 }
922}
923#[doc = "no description available\n\nValue on reset: 1"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum AdcLp {
927 #[doc = "0: enabled"]
928 Enabled = 0,
929 #[doc = "1: power down"]
930 PowerDown = 1,
931}
932impl From<AdcLp> for bool {
933 #[inline(always)]
934 fn from(variant: AdcLp) -> Self {
935 variant as u8 != 0
936 }
937}
938#[doc = "Field `ADC_LP` reader - no description available"]
939pub type AdcLpR = crate::BitReader<AdcLp>;
940impl AdcLpR {
941 #[doc = "Get enumerated values variant"]
942 #[inline(always)]
943 pub const fn variant(&self) -> AdcLp {
944 match self.bits {
945 false => AdcLp::Enabled,
946 true => AdcLp::PowerDown,
947 }
948 }
949 #[doc = "enabled"]
950 #[inline(always)]
951 pub fn is_enabled(&self) -> bool {
952 *self == AdcLp::Enabled
953 }
954 #[doc = "power down"]
955 #[inline(always)]
956 pub fn is_power_down(&self) -> bool {
957 *self == AdcLp::PowerDown
958 }
959}
960#[doc = "Field `ADC_LP` writer - no description available"]
961pub type AdcLpW<'a, REG> = crate::BitWriter<'a, REG, AdcLp>;
962impl<'a, REG> AdcLpW<'a, REG>
963where
964 REG: crate::Writable + crate::RegisterSpec,
965{
966 #[doc = "enabled"]
967 #[inline(always)]
968 pub fn enabled(self) -> &'a mut crate::W<REG> {
969 self.variant(AdcLp::Enabled)
970 }
971 #[doc = "power down"]
972 #[inline(always)]
973 pub fn power_down(self) -> &'a mut crate::W<REG> {
974 self.variant(AdcLp::PowerDown)
975 }
976}
977#[doc = "no description available\n\nValue on reset: 1"]
978#[cfg_attr(feature = "defmt", derive(defmt::Format))]
979#[derive(Clone, Copy, Debug, PartialEq, Eq)]
980pub enum AdctempsnsPd {
981 #[doc = "0: enabled"]
982 Enabled = 0,
983 #[doc = "1: power down"]
984 PowerDown = 1,
985}
986impl From<AdctempsnsPd> for bool {
987 #[inline(always)]
988 fn from(variant: AdctempsnsPd) -> Self {
989 variant as u8 != 0
990 }
991}
992#[doc = "Field `ADCTEMPSNS_PD` reader - no description available"]
993pub type AdctempsnsPdR = crate::BitReader<AdctempsnsPd>;
994impl AdctempsnsPdR {
995 #[doc = "Get enumerated values variant"]
996 #[inline(always)]
997 pub const fn variant(&self) -> AdctempsnsPd {
998 match self.bits {
999 false => AdctempsnsPd::Enabled,
1000 true => AdctempsnsPd::PowerDown,
1001 }
1002 }
1003 #[doc = "enabled"]
1004 #[inline(always)]
1005 pub fn is_enabled(&self) -> bool {
1006 *self == AdctempsnsPd::Enabled
1007 }
1008 #[doc = "power down"]
1009 #[inline(always)]
1010 pub fn is_power_down(&self) -> bool {
1011 *self == AdctempsnsPd::PowerDown
1012 }
1013}
1014#[doc = "Field `ADCTEMPSNS_PD` writer - no description available"]
1015pub type AdctempsnsPdW<'a, REG> = crate::BitWriter<'a, REG, AdctempsnsPd>;
1016impl<'a, REG> AdctempsnsPdW<'a, REG>
1017where
1018 REG: crate::Writable + crate::RegisterSpec,
1019{
1020 #[doc = "enabled"]
1021 #[inline(always)]
1022 pub fn enabled(self) -> &'a mut crate::W<REG> {
1023 self.variant(AdctempsnsPd::Enabled)
1024 }
1025 #[doc = "power down"]
1026 #[inline(always)]
1027 pub fn power_down(self) -> &'a mut crate::W<REG> {
1028 self.variant(AdctempsnsPd::PowerDown)
1029 }
1030}
1031#[doc = "no description available\n\nValue on reset: 1"]
1032#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1033#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1034pub enum AcmpPd {
1035 #[doc = "0: enabled"]
1036 Enabled = 0,
1037 #[doc = "1: power down"]
1038 PowerDown = 1,
1039}
1040impl From<AcmpPd> for bool {
1041 #[inline(always)]
1042 fn from(variant: AcmpPd) -> Self {
1043 variant as u8 != 0
1044 }
1045}
1046#[doc = "Field `ACMP_PD` reader - no description available"]
1047pub type AcmpPdR = crate::BitReader<AcmpPd>;
1048impl AcmpPdR {
1049 #[doc = "Get enumerated values variant"]
1050 #[inline(always)]
1051 pub const fn variant(&self) -> AcmpPd {
1052 match self.bits {
1053 false => AcmpPd::Enabled,
1054 true => AcmpPd::PowerDown,
1055 }
1056 }
1057 #[doc = "enabled"]
1058 #[inline(always)]
1059 pub fn is_enabled(&self) -> bool {
1060 *self == AcmpPd::Enabled
1061 }
1062 #[doc = "power down"]
1063 #[inline(always)]
1064 pub fn is_power_down(&self) -> bool {
1065 *self == AcmpPd::PowerDown
1066 }
1067}
1068#[doc = "Field `ACMP_PD` writer - no description available"]
1069pub type AcmpPdW<'a, REG> = crate::BitWriter<'a, REG, AcmpPd>;
1070impl<'a, REG> AcmpPdW<'a, REG>
1071where
1072 REG: crate::Writable + crate::RegisterSpec,
1073{
1074 #[doc = "enabled"]
1075 #[inline(always)]
1076 pub fn enabled(self) -> &'a mut crate::W<REG> {
1077 self.variant(AcmpPd::Enabled)
1078 }
1079 #[doc = "power down"]
1080 #[inline(always)]
1081 pub fn power_down(self) -> &'a mut crate::W<REG> {
1082 self.variant(AcmpPd::PowerDown)
1083 }
1084}
1085#[doc = "High Speed Pad vdde0 voltage detect block\n\nValue on reset: 0"]
1086#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1087#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1088pub enum Hspad0VdetLp {
1089 #[doc = "0: High Speed Pad VDET in Normal Mode"]
1090 NormalMode = 0,
1091 #[doc = "1: High Speed Pad VDET in Sleep Mode"]
1092 SleepMode = 1,
1093}
1094impl From<Hspad0VdetLp> for bool {
1095 #[inline(always)]
1096 fn from(variant: Hspad0VdetLp) -> Self {
1097 variant as u8 != 0
1098 }
1099}
1100#[doc = "Field `HSPAD0_VDET_LP` reader - High Speed Pad vdde0 voltage detect block"]
1101pub type Hspad0VdetLpR = crate::BitReader<Hspad0VdetLp>;
1102impl Hspad0VdetLpR {
1103 #[doc = "Get enumerated values variant"]
1104 #[inline(always)]
1105 pub const fn variant(&self) -> Hspad0VdetLp {
1106 match self.bits {
1107 false => Hspad0VdetLp::NormalMode,
1108 true => Hspad0VdetLp::SleepMode,
1109 }
1110 }
1111 #[doc = "High Speed Pad VDET in Normal Mode"]
1112 #[inline(always)]
1113 pub fn is_normal_mode(&self) -> bool {
1114 *self == Hspad0VdetLp::NormalMode
1115 }
1116 #[doc = "High Speed Pad VDET in Sleep Mode"]
1117 #[inline(always)]
1118 pub fn is_sleep_mode(&self) -> bool {
1119 *self == Hspad0VdetLp::SleepMode
1120 }
1121}
1122#[doc = "Field `HSPAD0_VDET_LP` writer - High Speed Pad vdde0 voltage detect block"]
1123pub type Hspad0VdetLpW<'a, REG> = crate::BitWriter<'a, REG, Hspad0VdetLp>;
1124impl<'a, REG> Hspad0VdetLpW<'a, REG>
1125where
1126 REG: crate::Writable + crate::RegisterSpec,
1127{
1128 #[doc = "High Speed Pad VDET in Normal Mode"]
1129 #[inline(always)]
1130 pub fn normal_mode(self) -> &'a mut crate::W<REG> {
1131 self.variant(Hspad0VdetLp::NormalMode)
1132 }
1133 #[doc = "High Speed Pad VDET in Sleep Mode"]
1134 #[inline(always)]
1135 pub fn sleep_mode(self) -> &'a mut crate::W<REG> {
1136 self.variant(Hspad0VdetLp::SleepMode)
1137 }
1138}
1139#[doc = "High speed Pad vdde0 reference blocks\n\nValue on reset: 0"]
1140#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1142pub enum Hspad0RefPd {
1143 #[doc = "0: High Speed Pad VREF Enabled"]
1144 Enabled = 0,
1145 #[doc = "1: High Speed Pad VREF in Power Down"]
1146 PowerDown = 1,
1147}
1148impl From<Hspad0RefPd> for bool {
1149 #[inline(always)]
1150 fn from(variant: Hspad0RefPd) -> Self {
1151 variant as u8 != 0
1152 }
1153}
1154#[doc = "Field `HSPAD0_REF_PD` reader - High speed Pad vdde0 reference blocks"]
1155pub type Hspad0RefPdR = crate::BitReader<Hspad0RefPd>;
1156impl Hspad0RefPdR {
1157 #[doc = "Get enumerated values variant"]
1158 #[inline(always)]
1159 pub const fn variant(&self) -> Hspad0RefPd {
1160 match self.bits {
1161 false => Hspad0RefPd::Enabled,
1162 true => Hspad0RefPd::PowerDown,
1163 }
1164 }
1165 #[doc = "High Speed Pad VREF Enabled"]
1166 #[inline(always)]
1167 pub fn is_enabled(&self) -> bool {
1168 *self == Hspad0RefPd::Enabled
1169 }
1170 #[doc = "High Speed Pad VREF in Power Down"]
1171 #[inline(always)]
1172 pub fn is_power_down(&self) -> bool {
1173 *self == Hspad0RefPd::PowerDown
1174 }
1175}
1176#[doc = "Field `HSPAD0_REF_PD` writer - High speed Pad vdde0 reference blocks"]
1177pub type Hspad0RefPdW<'a, REG> = crate::BitWriter<'a, REG, Hspad0RefPd>;
1178impl<'a, REG> Hspad0RefPdW<'a, REG>
1179where
1180 REG: crate::Writable + crate::RegisterSpec,
1181{
1182 #[doc = "High Speed Pad VREF Enabled"]
1183 #[inline(always)]
1184 pub fn enabled(self) -> &'a mut crate::W<REG> {
1185 self.variant(Hspad0RefPd::Enabled)
1186 }
1187 #[doc = "High Speed Pad VREF in Power Down"]
1188 #[inline(always)]
1189 pub fn power_down(self) -> &'a mut crate::W<REG> {
1190 self.variant(Hspad0RefPd::PowerDown)
1191 }
1192}
1193#[doc = "High Speed Pad vdde2 voltage detect block\n\nValue on reset: 0"]
1194#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1195#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1196pub enum Hspad2VdetLp {
1197 #[doc = "0: High Speed Pad VDET in Normal Mode"]
1198 NormalMode = 0,
1199 #[doc = "1: High Speed Pad VDET in Sleep Mode"]
1200 SleepMode = 1,
1201}
1202impl From<Hspad2VdetLp> for bool {
1203 #[inline(always)]
1204 fn from(variant: Hspad2VdetLp) -> Self {
1205 variant as u8 != 0
1206 }
1207}
1208#[doc = "Field `HSPAD2_VDET_LP` reader - High Speed Pad vdde2 voltage detect block"]
1209pub type Hspad2VdetLpR = crate::BitReader<Hspad2VdetLp>;
1210impl Hspad2VdetLpR {
1211 #[doc = "Get enumerated values variant"]
1212 #[inline(always)]
1213 pub const fn variant(&self) -> Hspad2VdetLp {
1214 match self.bits {
1215 false => Hspad2VdetLp::NormalMode,
1216 true => Hspad2VdetLp::SleepMode,
1217 }
1218 }
1219 #[doc = "High Speed Pad VDET in Normal Mode"]
1220 #[inline(always)]
1221 pub fn is_normal_mode(&self) -> bool {
1222 *self == Hspad2VdetLp::NormalMode
1223 }
1224 #[doc = "High Speed Pad VDET in Sleep Mode"]
1225 #[inline(always)]
1226 pub fn is_sleep_mode(&self) -> bool {
1227 *self == Hspad2VdetLp::SleepMode
1228 }
1229}
1230#[doc = "Field `HSPAD2_VDET_LP` writer - High Speed Pad vdde2 voltage detect block"]
1231pub type Hspad2VdetLpW<'a, REG> = crate::BitWriter<'a, REG, Hspad2VdetLp>;
1232impl<'a, REG> Hspad2VdetLpW<'a, REG>
1233where
1234 REG: crate::Writable + crate::RegisterSpec,
1235{
1236 #[doc = "High Speed Pad VDET in Normal Mode"]
1237 #[inline(always)]
1238 pub fn normal_mode(self) -> &'a mut crate::W<REG> {
1239 self.variant(Hspad2VdetLp::NormalMode)
1240 }
1241 #[doc = "High Speed Pad VDET in Sleep Mode"]
1242 #[inline(always)]
1243 pub fn sleep_mode(self) -> &'a mut crate::W<REG> {
1244 self.variant(Hspad2VdetLp::SleepMode)
1245 }
1246}
1247#[doc = "High speed Pad vdde2 reference blocks\n\nValue on reset: 0"]
1248#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1249#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1250pub enum Hspad2RefPd {
1251 #[doc = "0: High Speed Pad VREF Enabled"]
1252 Enabled = 0,
1253 #[doc = "1: High Speed Pad VREF in Power Down"]
1254 PowerDown = 1,
1255}
1256impl From<Hspad2RefPd> for bool {
1257 #[inline(always)]
1258 fn from(variant: Hspad2RefPd) -> Self {
1259 variant as u8 != 0
1260 }
1261}
1262#[doc = "Field `HSPAD2_REF_PD` reader - High speed Pad vdde2 reference blocks"]
1263pub type Hspad2RefPdR = crate::BitReader<Hspad2RefPd>;
1264impl Hspad2RefPdR {
1265 #[doc = "Get enumerated values variant"]
1266 #[inline(always)]
1267 pub const fn variant(&self) -> Hspad2RefPd {
1268 match self.bits {
1269 false => Hspad2RefPd::Enabled,
1270 true => Hspad2RefPd::PowerDown,
1271 }
1272 }
1273 #[doc = "High Speed Pad VREF Enabled"]
1274 #[inline(always)]
1275 pub fn is_enabled(&self) -> bool {
1276 *self == Hspad2RefPd::Enabled
1277 }
1278 #[doc = "High Speed Pad VREF in Power Down"]
1279 #[inline(always)]
1280 pub fn is_power_down(&self) -> bool {
1281 *self == Hspad2RefPd::PowerDown
1282 }
1283}
1284#[doc = "Field `HSPAD2_REF_PD` writer - High speed Pad vdde2 reference blocks"]
1285pub type Hspad2RefPdW<'a, REG> = crate::BitWriter<'a, REG, Hspad2RefPd>;
1286impl<'a, REG> Hspad2RefPdW<'a, REG>
1287where
1288 REG: crate::Writable + crate::RegisterSpec,
1289{
1290 #[doc = "High Speed Pad VREF Enabled"]
1291 #[inline(always)]
1292 pub fn enabled(self) -> &'a mut crate::W<REG> {
1293 self.variant(Hspad2RefPd::Enabled)
1294 }
1295 #[doc = "High Speed Pad VREF in Power Down"]
1296 #[inline(always)]
1297 pub fn power_down(self) -> &'a mut crate::W<REG> {
1298 self.variant(Hspad2RefPd::PowerDown)
1299 }
1300}
1301impl R {
1302 #[doc = "Bit 1 - no description available"]
1303 #[inline(always)]
1304 pub fn pmic_mode0(&self) -> PmicMode0R {
1305 PmicMode0R::new(((self.bits >> 1) & 1) != 0)
1306 }
1307 #[doc = "Bit 2 - no description available"]
1308 #[inline(always)]
1309 pub fn pmic_mode1(&self) -> PmicMode1R {
1310 PmicMode1R::new(((self.bits >> 2) & 1) != 0)
1311 }
1312 #[doc = "Bit 4 - no description available"]
1313 #[inline(always)]
1314 pub fn vddcorereg_lp(&self) -> VddcoreregLpR {
1315 VddcoreregLpR::new(((self.bits >> 4) & 1) != 0)
1316 }
1317 #[doc = "Bit 6 - no description available"]
1318 #[inline(always)]
1319 pub fn pmcref_lp(&self) -> PmcrefLpR {
1320 PmcrefLpR::new(((self.bits >> 6) & 1) != 0)
1321 }
1322 #[doc = "Bit 7 - no description available"]
1323 #[inline(always)]
1324 pub fn hvd1v8_pd(&self) -> Hvd1v8PdR {
1325 Hvd1v8PdR::new(((self.bits >> 7) & 1) != 0)
1326 }
1327 #[doc = "Bit 8 - no description available"]
1328 #[inline(always)]
1329 pub fn porcore_lp(&self) -> PorcoreLpR {
1330 PorcoreLpR::new(((self.bits >> 8) & 1) != 0)
1331 }
1332 #[doc = "Bit 9 - no description available"]
1333 #[inline(always)]
1334 pub fn lvdcore_lp(&self) -> LvdcoreLpR {
1335 LvdcoreLpR::new(((self.bits >> 9) & 1) != 0)
1336 }
1337 #[doc = "Bit 10 - no description available"]
1338 #[inline(always)]
1339 pub fn hvdcore_pd(&self) -> HvdcorePdR {
1340 HvdcorePdR::new(((self.bits >> 10) & 1) != 0)
1341 }
1342 #[doc = "Bit 13 - no description available"]
1343 #[inline(always)]
1344 pub fn sysxtal_pd(&self) -> SysxtalPdR {
1345 SysxtalPdR::new(((self.bits >> 13) & 1) != 0)
1346 }
1347 #[doc = "Bit 14 - no description available"]
1348 #[inline(always)]
1349 pub fn lposc_pd(&self) -> LposcPdR {
1350 LposcPdR::new(((self.bits >> 14) & 1) != 0)
1351 }
1352 #[doc = "Bit 15 - no description available"]
1353 #[inline(always)]
1354 pub fn sfro_pd(&self) -> SfroPdR {
1355 SfroPdR::new(((self.bits >> 15) & 1) != 0)
1356 }
1357 #[doc = "Bit 16 - no description available"]
1358 #[inline(always)]
1359 pub fn ffro_pd(&self) -> FfroPdR {
1360 FfroPdR::new(((self.bits >> 16) & 1) != 0)
1361 }
1362 #[doc = "Bit 17 - no description available"]
1363 #[inline(always)]
1364 pub fn syspllldo_pd(&self) -> SyspllldoPdR {
1365 SyspllldoPdR::new(((self.bits >> 17) & 1) != 0)
1366 }
1367 #[doc = "Bit 18 - no description available"]
1368 #[inline(always)]
1369 pub fn syspllana_pd(&self) -> SyspllanaPdR {
1370 SyspllanaPdR::new(((self.bits >> 18) & 1) != 0)
1371 }
1372 #[doc = "Bit 19 - no description available"]
1373 #[inline(always)]
1374 pub fn audpllldo_pd(&self) -> AudpllldoPdR {
1375 AudpllldoPdR::new(((self.bits >> 19) & 1) != 0)
1376 }
1377 #[doc = "Bit 20 - no description available"]
1378 #[inline(always)]
1379 pub fn audpllana_pd(&self) -> AudpllanaPdR {
1380 AudpllanaPdR::new(((self.bits >> 20) & 1) != 0)
1381 }
1382 #[doc = "Bit 21 - no description available"]
1383 #[inline(always)]
1384 pub fn adc_pd(&self) -> AdcPdR {
1385 AdcPdR::new(((self.bits >> 21) & 1) != 0)
1386 }
1387 #[doc = "Bit 22 - no description available"]
1388 #[inline(always)]
1389 pub fn adc_lp(&self) -> AdcLpR {
1390 AdcLpR::new(((self.bits >> 22) & 1) != 0)
1391 }
1392 #[doc = "Bit 23 - no description available"]
1393 #[inline(always)]
1394 pub fn adctempsns_pd(&self) -> AdctempsnsPdR {
1395 AdctempsnsPdR::new(((self.bits >> 23) & 1) != 0)
1396 }
1397 #[doc = "Bit 25 - no description available"]
1398 #[inline(always)]
1399 pub fn acmp_pd(&self) -> AcmpPdR {
1400 AcmpPdR::new(((self.bits >> 25) & 1) != 0)
1401 }
1402 #[doc = "Bit 26 - High Speed Pad vdde0 voltage detect block"]
1403 #[inline(always)]
1404 pub fn hspad0_vdet_lp(&self) -> Hspad0VdetLpR {
1405 Hspad0VdetLpR::new(((self.bits >> 26) & 1) != 0)
1406 }
1407 #[doc = "Bit 27 - High speed Pad vdde0 reference blocks"]
1408 #[inline(always)]
1409 pub fn hspad0_ref_pd(&self) -> Hspad0RefPdR {
1410 Hspad0RefPdR::new(((self.bits >> 27) & 1) != 0)
1411 }
1412 #[doc = "Bit 28 - High Speed Pad vdde2 voltage detect block"]
1413 #[inline(always)]
1414 pub fn hspad2_vdet_lp(&self) -> Hspad2VdetLpR {
1415 Hspad2VdetLpR::new(((self.bits >> 28) & 1) != 0)
1416 }
1417 #[doc = "Bit 29 - High speed Pad vdde2 reference blocks"]
1418 #[inline(always)]
1419 pub fn hspad2_ref_pd(&self) -> Hspad2RefPdR {
1420 Hspad2RefPdR::new(((self.bits >> 29) & 1) != 0)
1421 }
1422}
1423#[cfg(feature = "debug")]
1424impl core::fmt::Debug for R {
1425 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1426 f.debug_struct("PDRUNCFG0")
1427 .field("pmic_mode0", &self.pmic_mode0())
1428 .field("pmic_mode1", &self.pmic_mode1())
1429 .field("vddcorereg_lp", &self.vddcorereg_lp())
1430 .field("pmcref_lp", &self.pmcref_lp())
1431 .field("hvd1v8_pd", &self.hvd1v8_pd())
1432 .field("porcore_lp", &self.porcore_lp())
1433 .field("lvdcore_lp", &self.lvdcore_lp())
1434 .field("hvdcore_pd", &self.hvdcore_pd())
1435 .field("sysxtal_pd", &self.sysxtal_pd())
1436 .field("lposc_pd", &self.lposc_pd())
1437 .field("sfro_pd", &self.sfro_pd())
1438 .field("ffro_pd", &self.ffro_pd())
1439 .field("syspllldo_pd", &self.syspllldo_pd())
1440 .field("syspllana_pd", &self.syspllana_pd())
1441 .field("audpllldo_pd", &self.audpllldo_pd())
1442 .field("audpllana_pd", &self.audpllana_pd())
1443 .field("adc_pd", &self.adc_pd())
1444 .field("adc_lp", &self.adc_lp())
1445 .field("adctempsns_pd", &self.adctempsns_pd())
1446 .field("acmp_pd", &self.acmp_pd())
1447 .field("hspad0_vdet_lp", &self.hspad0_vdet_lp())
1448 .field("hspad0_ref_pd", &self.hspad0_ref_pd())
1449 .field("hspad2_vdet_lp", &self.hspad2_vdet_lp())
1450 .field("hspad2_ref_pd", &self.hspad2_ref_pd())
1451 .finish()
1452 }
1453}
1454impl W {
1455 #[doc = "Bit 1 - no description available"]
1456 #[inline(always)]
1457 pub fn pmic_mode0(&mut self) -> PmicMode0W<Pdruncfg0Spec> {
1458 PmicMode0W::new(self, 1)
1459 }
1460 #[doc = "Bit 2 - no description available"]
1461 #[inline(always)]
1462 pub fn pmic_mode1(&mut self) -> PmicMode1W<Pdruncfg0Spec> {
1463 PmicMode1W::new(self, 2)
1464 }
1465 #[doc = "Bit 4 - no description available"]
1466 #[inline(always)]
1467 pub fn vddcorereg_lp(&mut self) -> VddcoreregLpW<Pdruncfg0Spec> {
1468 VddcoreregLpW::new(self, 4)
1469 }
1470 #[doc = "Bit 6 - no description available"]
1471 #[inline(always)]
1472 pub fn pmcref_lp(&mut self) -> PmcrefLpW<Pdruncfg0Spec> {
1473 PmcrefLpW::new(self, 6)
1474 }
1475 #[doc = "Bit 7 - no description available"]
1476 #[inline(always)]
1477 pub fn hvd1v8_pd(&mut self) -> Hvd1v8PdW<Pdruncfg0Spec> {
1478 Hvd1v8PdW::new(self, 7)
1479 }
1480 #[doc = "Bit 8 - no description available"]
1481 #[inline(always)]
1482 pub fn porcore_lp(&mut self) -> PorcoreLpW<Pdruncfg0Spec> {
1483 PorcoreLpW::new(self, 8)
1484 }
1485 #[doc = "Bit 9 - no description available"]
1486 #[inline(always)]
1487 pub fn lvdcore_lp(&mut self) -> LvdcoreLpW<Pdruncfg0Spec> {
1488 LvdcoreLpW::new(self, 9)
1489 }
1490 #[doc = "Bit 10 - no description available"]
1491 #[inline(always)]
1492 pub fn hvdcore_pd(&mut self) -> HvdcorePdW<Pdruncfg0Spec> {
1493 HvdcorePdW::new(self, 10)
1494 }
1495 #[doc = "Bit 13 - no description available"]
1496 #[inline(always)]
1497 pub fn sysxtal_pd(&mut self) -> SysxtalPdW<Pdruncfg0Spec> {
1498 SysxtalPdW::new(self, 13)
1499 }
1500 #[doc = "Bit 14 - no description available"]
1501 #[inline(always)]
1502 pub fn lposc_pd(&mut self) -> LposcPdW<Pdruncfg0Spec> {
1503 LposcPdW::new(self, 14)
1504 }
1505 #[doc = "Bit 15 - no description available"]
1506 #[inline(always)]
1507 pub fn sfro_pd(&mut self) -> SfroPdW<Pdruncfg0Spec> {
1508 SfroPdW::new(self, 15)
1509 }
1510 #[doc = "Bit 16 - no description available"]
1511 #[inline(always)]
1512 pub fn ffro_pd(&mut self) -> FfroPdW<Pdruncfg0Spec> {
1513 FfroPdW::new(self, 16)
1514 }
1515 #[doc = "Bit 17 - no description available"]
1516 #[inline(always)]
1517 pub fn syspllldo_pd(&mut self) -> SyspllldoPdW<Pdruncfg0Spec> {
1518 SyspllldoPdW::new(self, 17)
1519 }
1520 #[doc = "Bit 18 - no description available"]
1521 #[inline(always)]
1522 pub fn syspllana_pd(&mut self) -> SyspllanaPdW<Pdruncfg0Spec> {
1523 SyspllanaPdW::new(self, 18)
1524 }
1525 #[doc = "Bit 19 - no description available"]
1526 #[inline(always)]
1527 pub fn audpllldo_pd(&mut self) -> AudpllldoPdW<Pdruncfg0Spec> {
1528 AudpllldoPdW::new(self, 19)
1529 }
1530 #[doc = "Bit 20 - no description available"]
1531 #[inline(always)]
1532 pub fn audpllana_pd(&mut self) -> AudpllanaPdW<Pdruncfg0Spec> {
1533 AudpllanaPdW::new(self, 20)
1534 }
1535 #[doc = "Bit 21 - no description available"]
1536 #[inline(always)]
1537 pub fn adc_pd(&mut self) -> AdcPdW<Pdruncfg0Spec> {
1538 AdcPdW::new(self, 21)
1539 }
1540 #[doc = "Bit 22 - no description available"]
1541 #[inline(always)]
1542 pub fn adc_lp(&mut self) -> AdcLpW<Pdruncfg0Spec> {
1543 AdcLpW::new(self, 22)
1544 }
1545 #[doc = "Bit 23 - no description available"]
1546 #[inline(always)]
1547 pub fn adctempsns_pd(&mut self) -> AdctempsnsPdW<Pdruncfg0Spec> {
1548 AdctempsnsPdW::new(self, 23)
1549 }
1550 #[doc = "Bit 25 - no description available"]
1551 #[inline(always)]
1552 pub fn acmp_pd(&mut self) -> AcmpPdW<Pdruncfg0Spec> {
1553 AcmpPdW::new(self, 25)
1554 }
1555 #[doc = "Bit 26 - High Speed Pad vdde0 voltage detect block"]
1556 #[inline(always)]
1557 pub fn hspad0_vdet_lp(&mut self) -> Hspad0VdetLpW<Pdruncfg0Spec> {
1558 Hspad0VdetLpW::new(self, 26)
1559 }
1560 #[doc = "Bit 27 - High speed Pad vdde0 reference blocks"]
1561 #[inline(always)]
1562 pub fn hspad0_ref_pd(&mut self) -> Hspad0RefPdW<Pdruncfg0Spec> {
1563 Hspad0RefPdW::new(self, 27)
1564 }
1565 #[doc = "Bit 28 - High Speed Pad vdde2 voltage detect block"]
1566 #[inline(always)]
1567 pub fn hspad2_vdet_lp(&mut self) -> Hspad2VdetLpW<Pdruncfg0Spec> {
1568 Hspad2VdetLpW::new(self, 28)
1569 }
1570 #[doc = "Bit 29 - High speed Pad vdde2 reference blocks"]
1571 #[inline(always)]
1572 pub fn hspad2_ref_pd(&mut self) -> Hspad2RefPdW<Pdruncfg0Spec> {
1573 Hspad2RefPdW::new(self, 29)
1574 }
1575}
1576#[doc = "Run configuration 0\n\nYou can [`read`](crate::Reg::read) this register and get [`pdruncfg0::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pdruncfg0::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1577pub struct Pdruncfg0Spec;
1578impl crate::RegisterSpec for Pdruncfg0Spec {
1579 type Ux = u32;
1580}
1581#[doc = "`read()` method returns [`pdruncfg0::R`](R) reader structure"]
1582impl crate::Readable for Pdruncfg0Spec {}
1583#[doc = "`write(|w| ..)` method takes [`pdruncfg0::W`](W) writer structure"]
1584impl crate::Writable for Pdruncfg0Spec {
1585 type Safety = crate::Unsafe;
1586 const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1587 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1588}
1589#[doc = "`reset()` method sets PDRUNCFG0 to value 0x03fe_bc80"]
1590impl crate::Resettable for Pdruncfg0Spec {
1591 const RESET_VALUE: u32 = 0x03fe_bc80;
1592}