mcxa_pac/mrcc0/
mrcc_glb_rst1.rs

1#[doc = "Register `MRCC_GLB_RST1` reader"]
2pub type R = crate::R<MrccGlbRst1Spec>;
3#[doc = "Register `MRCC_GLB_RST1` writer"]
4pub type W = crate::W<MrccGlbRst1Spec>;
5#[doc = "FLEXPWM1\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Flexpwm1 {
9    #[doc = "0: Peripheral is held in reset"]
10    Disabled = 0,
11    #[doc = "1: Peripheral is released from reset"]
12    Enabled = 1,
13}
14impl From<Flexpwm1> for bool {
15    #[inline(always)]
16    fn from(variant: Flexpwm1) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `FLEXPWM1` reader - FLEXPWM1"]
21pub type Flexpwm1R = crate::BitReader<Flexpwm1>;
22impl Flexpwm1R {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Flexpwm1 {
26        match self.bits {
27            false => Flexpwm1::Disabled,
28            true => Flexpwm1::Enabled,
29        }
30    }
31    #[doc = "Peripheral is held in reset"]
32    #[inline(always)]
33    pub fn is_disabled(&self) -> bool {
34        *self == Flexpwm1::Disabled
35    }
36    #[doc = "Peripheral is released from reset"]
37    #[inline(always)]
38    pub fn is_enabled(&self) -> bool {
39        *self == Flexpwm1::Enabled
40    }
41}
42#[doc = "Field `FLEXPWM1` writer - FLEXPWM1"]
43pub type Flexpwm1W<'a, REG> = crate::BitWriter<'a, REG, Flexpwm1>;
44impl<'a, REG> Flexpwm1W<'a, REG>
45where
46    REG: crate::Writable + crate::RegisterSpec,
47{
48    #[doc = "Peripheral is held in reset"]
49    #[inline(always)]
50    pub fn disabled(self) -> &'a mut crate::W<REG> {
51        self.variant(Flexpwm1::Disabled)
52    }
53    #[doc = "Peripheral is released from reset"]
54    #[inline(always)]
55    pub fn enabled(self) -> &'a mut crate::W<REG> {
56        self.variant(Flexpwm1::Enabled)
57    }
58}
59#[doc = "OSTIMER0\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Ostimer0 {
63    #[doc = "0: Peripheral is held in reset"]
64    Disabled = 0,
65    #[doc = "1: Peripheral is released from reset"]
66    Enabled = 1,
67}
68impl From<Ostimer0> for bool {
69    #[inline(always)]
70    fn from(variant: Ostimer0) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `OSTIMER0` reader - OSTIMER0"]
75pub type Ostimer0R = crate::BitReader<Ostimer0>;
76impl Ostimer0R {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Ostimer0 {
80        match self.bits {
81            false => Ostimer0::Disabled,
82            true => Ostimer0::Enabled,
83        }
84    }
85    #[doc = "Peripheral is held in reset"]
86    #[inline(always)]
87    pub fn is_disabled(&self) -> bool {
88        *self == Ostimer0::Disabled
89    }
90    #[doc = "Peripheral is released from reset"]
91    #[inline(always)]
92    pub fn is_enabled(&self) -> bool {
93        *self == Ostimer0::Enabled
94    }
95}
96#[doc = "Field `OSTIMER0` writer - OSTIMER0"]
97pub type Ostimer0W<'a, REG> = crate::BitWriter<'a, REG, Ostimer0>;
98impl<'a, REG> Ostimer0W<'a, REG>
99where
100    REG: crate::Writable + crate::RegisterSpec,
101{
102    #[doc = "Peripheral is held in reset"]
103    #[inline(always)]
104    pub fn disabled(self) -> &'a mut crate::W<REG> {
105        self.variant(Ostimer0::Disabled)
106    }
107    #[doc = "Peripheral is released from reset"]
108    #[inline(always)]
109    pub fn enabled(self) -> &'a mut crate::W<REG> {
110        self.variant(Ostimer0::Enabled)
111    }
112}
113#[doc = "ADC0\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Adc0 {
117    #[doc = "0: Peripheral is held in reset"]
118    Disabled = 0,
119    #[doc = "1: Peripheral is released from reset"]
120    Enabled = 1,
121}
122impl From<Adc0> for bool {
123    #[inline(always)]
124    fn from(variant: Adc0) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `ADC0` reader - ADC0"]
129pub type Adc0R = crate::BitReader<Adc0>;
130impl Adc0R {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> Adc0 {
134        match self.bits {
135            false => Adc0::Disabled,
136            true => Adc0::Enabled,
137        }
138    }
139    #[doc = "Peripheral is held in reset"]
140    #[inline(always)]
141    pub fn is_disabled(&self) -> bool {
142        *self == Adc0::Disabled
143    }
144    #[doc = "Peripheral is released from reset"]
145    #[inline(always)]
146    pub fn is_enabled(&self) -> bool {
147        *self == Adc0::Enabled
148    }
149}
150#[doc = "Field `ADC0` writer - ADC0"]
151pub type Adc0W<'a, REG> = crate::BitWriter<'a, REG, Adc0>;
152impl<'a, REG> Adc0W<'a, REG>
153where
154    REG: crate::Writable + crate::RegisterSpec,
155{
156    #[doc = "Peripheral is held in reset"]
157    #[inline(always)]
158    pub fn disabled(self) -> &'a mut crate::W<REG> {
159        self.variant(Adc0::Disabled)
160    }
161    #[doc = "Peripheral is released from reset"]
162    #[inline(always)]
163    pub fn enabled(self) -> &'a mut crate::W<REG> {
164        self.variant(Adc0::Enabled)
165    }
166}
167#[doc = "ADC1\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Adc1 {
171    #[doc = "0: Peripheral is held in reset"]
172    Disabled = 0,
173    #[doc = "1: Peripheral is released from reset"]
174    Enabled = 1,
175}
176impl From<Adc1> for bool {
177    #[inline(always)]
178    fn from(variant: Adc1) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `ADC1` reader - ADC1"]
183pub type Adc1R = crate::BitReader<Adc1>;
184impl Adc1R {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> Adc1 {
188        match self.bits {
189            false => Adc1::Disabled,
190            true => Adc1::Enabled,
191        }
192    }
193    #[doc = "Peripheral is held in reset"]
194    #[inline(always)]
195    pub fn is_disabled(&self) -> bool {
196        *self == Adc1::Disabled
197    }
198    #[doc = "Peripheral is released from reset"]
199    #[inline(always)]
200    pub fn is_enabled(&self) -> bool {
201        *self == Adc1::Enabled
202    }
203}
204#[doc = "Field `ADC1` writer - ADC1"]
205pub type Adc1W<'a, REG> = crate::BitWriter<'a, REG, Adc1>;
206impl<'a, REG> Adc1W<'a, REG>
207where
208    REG: crate::Writable + crate::RegisterSpec,
209{
210    #[doc = "Peripheral is held in reset"]
211    #[inline(always)]
212    pub fn disabled(self) -> &'a mut crate::W<REG> {
213        self.variant(Adc1::Disabled)
214    }
215    #[doc = "Peripheral is released from reset"]
216    #[inline(always)]
217    pub fn enabled(self) -> &'a mut crate::W<REG> {
218        self.variant(Adc1::Enabled)
219    }
220}
221#[doc = "CMP1\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Cmp1 {
225    #[doc = "0: Peripheral is held in reset"]
226    Disabled = 0,
227    #[doc = "1: Peripheral is released from reset"]
228    Enabled = 1,
229}
230impl From<Cmp1> for bool {
231    #[inline(always)]
232    fn from(variant: Cmp1) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `CMP1` reader - CMP1"]
237pub type Cmp1R = crate::BitReader<Cmp1>;
238impl Cmp1R {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> Cmp1 {
242        match self.bits {
243            false => Cmp1::Disabled,
244            true => Cmp1::Enabled,
245        }
246    }
247    #[doc = "Peripheral is held in reset"]
248    #[inline(always)]
249    pub fn is_disabled(&self) -> bool {
250        *self == Cmp1::Disabled
251    }
252    #[doc = "Peripheral is released from reset"]
253    #[inline(always)]
254    pub fn is_enabled(&self) -> bool {
255        *self == Cmp1::Enabled
256    }
257}
258#[doc = "Field `CMP1` writer - CMP1"]
259pub type Cmp1W<'a, REG> = crate::BitWriter<'a, REG, Cmp1>;
260impl<'a, REG> Cmp1W<'a, REG>
261where
262    REG: crate::Writable + crate::RegisterSpec,
263{
264    #[doc = "Peripheral is held in reset"]
265    #[inline(always)]
266    pub fn disabled(self) -> &'a mut crate::W<REG> {
267        self.variant(Cmp1::Disabled)
268    }
269    #[doc = "Peripheral is released from reset"]
270    #[inline(always)]
271    pub fn enabled(self) -> &'a mut crate::W<REG> {
272        self.variant(Cmp1::Enabled)
273    }
274}
275#[doc = "CMP2\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Cmp2 {
279    #[doc = "0: Peripheral is held in reset"]
280    Disabled = 0,
281    #[doc = "1: Peripheral is released from reset"]
282    Enabled = 1,
283}
284impl From<Cmp2> for bool {
285    #[inline(always)]
286    fn from(variant: Cmp2) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `CMP2` reader - CMP2"]
291pub type Cmp2R = crate::BitReader<Cmp2>;
292impl Cmp2R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> Cmp2 {
296        match self.bits {
297            false => Cmp2::Disabled,
298            true => Cmp2::Enabled,
299        }
300    }
301    #[doc = "Peripheral is held in reset"]
302    #[inline(always)]
303    pub fn is_disabled(&self) -> bool {
304        *self == Cmp2::Disabled
305    }
306    #[doc = "Peripheral is released from reset"]
307    #[inline(always)]
308    pub fn is_enabled(&self) -> bool {
309        *self == Cmp2::Enabled
310    }
311}
312#[doc = "Field `CMP2` writer - CMP2"]
313pub type Cmp2W<'a, REG> = crate::BitWriter<'a, REG, Cmp2>;
314impl<'a, REG> Cmp2W<'a, REG>
315where
316    REG: crate::Writable + crate::RegisterSpec,
317{
318    #[doc = "Peripheral is held in reset"]
319    #[inline(always)]
320    pub fn disabled(self) -> &'a mut crate::W<REG> {
321        self.variant(Cmp2::Disabled)
322    }
323    #[doc = "Peripheral is released from reset"]
324    #[inline(always)]
325    pub fn enabled(self) -> &'a mut crate::W<REG> {
326        self.variant(Cmp2::Enabled)
327    }
328}
329#[doc = "DAC0\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Dac0 {
333    #[doc = "0: Peripheral is held in reset"]
334    Disabled = 0,
335    #[doc = "1: Peripheral is released from reset"]
336    Enabled = 1,
337}
338impl From<Dac0> for bool {
339    #[inline(always)]
340    fn from(variant: Dac0) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `DAC0` reader - DAC0"]
345pub type Dac0R = crate::BitReader<Dac0>;
346impl Dac0R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> Dac0 {
350        match self.bits {
351            false => Dac0::Disabled,
352            true => Dac0::Enabled,
353        }
354    }
355    #[doc = "Peripheral is held in reset"]
356    #[inline(always)]
357    pub fn is_disabled(&self) -> bool {
358        *self == Dac0::Disabled
359    }
360    #[doc = "Peripheral is released from reset"]
361    #[inline(always)]
362    pub fn is_enabled(&self) -> bool {
363        *self == Dac0::Enabled
364    }
365}
366#[doc = "Field `DAC0` writer - DAC0"]
367pub type Dac0W<'a, REG> = crate::BitWriter<'a, REG, Dac0>;
368impl<'a, REG> Dac0W<'a, REG>
369where
370    REG: crate::Writable + crate::RegisterSpec,
371{
372    #[doc = "Peripheral is held in reset"]
373    #[inline(always)]
374    pub fn disabled(self) -> &'a mut crate::W<REG> {
375        self.variant(Dac0::Disabled)
376    }
377    #[doc = "Peripheral is released from reset"]
378    #[inline(always)]
379    pub fn enabled(self) -> &'a mut crate::W<REG> {
380        self.variant(Dac0::Enabled)
381    }
382}
383#[doc = "OPAMP0\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Opamp0 {
387    #[doc = "0: Peripheral is held in reset"]
388    Disabled = 0,
389    #[doc = "1: Peripheral is released from reset"]
390    Enabled = 1,
391}
392impl From<Opamp0> for bool {
393    #[inline(always)]
394    fn from(variant: Opamp0) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `OPAMP0` reader - OPAMP0"]
399pub type Opamp0R = crate::BitReader<Opamp0>;
400impl Opamp0R {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> Opamp0 {
404        match self.bits {
405            false => Opamp0::Disabled,
406            true => Opamp0::Enabled,
407        }
408    }
409    #[doc = "Peripheral is held in reset"]
410    #[inline(always)]
411    pub fn is_disabled(&self) -> bool {
412        *self == Opamp0::Disabled
413    }
414    #[doc = "Peripheral is released from reset"]
415    #[inline(always)]
416    pub fn is_enabled(&self) -> bool {
417        *self == Opamp0::Enabled
418    }
419}
420#[doc = "Field `OPAMP0` writer - OPAMP0"]
421pub type Opamp0W<'a, REG> = crate::BitWriter<'a, REG, Opamp0>;
422impl<'a, REG> Opamp0W<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "Peripheral is held in reset"]
427    #[inline(always)]
428    pub fn disabled(self) -> &'a mut crate::W<REG> {
429        self.variant(Opamp0::Disabled)
430    }
431    #[doc = "Peripheral is released from reset"]
432    #[inline(always)]
433    pub fn enabled(self) -> &'a mut crate::W<REG> {
434        self.variant(Opamp0::Enabled)
435    }
436}
437#[doc = "OPAMP1\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Opamp1 {
441    #[doc = "0: Peripheral is held in reset"]
442    Disabled = 0,
443    #[doc = "1: Peripheral is released from reset"]
444    Enabled = 1,
445}
446impl From<Opamp1> for bool {
447    #[inline(always)]
448    fn from(variant: Opamp1) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `OPAMP1` reader - OPAMP1"]
453pub type Opamp1R = crate::BitReader<Opamp1>;
454impl Opamp1R {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> Opamp1 {
458        match self.bits {
459            false => Opamp1::Disabled,
460            true => Opamp1::Enabled,
461        }
462    }
463    #[doc = "Peripheral is held in reset"]
464    #[inline(always)]
465    pub fn is_disabled(&self) -> bool {
466        *self == Opamp1::Disabled
467    }
468    #[doc = "Peripheral is released from reset"]
469    #[inline(always)]
470    pub fn is_enabled(&self) -> bool {
471        *self == Opamp1::Enabled
472    }
473}
474#[doc = "Field `OPAMP1` writer - OPAMP1"]
475pub type Opamp1W<'a, REG> = crate::BitWriter<'a, REG, Opamp1>;
476impl<'a, REG> Opamp1W<'a, REG>
477where
478    REG: crate::Writable + crate::RegisterSpec,
479{
480    #[doc = "Peripheral is held in reset"]
481    #[inline(always)]
482    pub fn disabled(self) -> &'a mut crate::W<REG> {
483        self.variant(Opamp1::Disabled)
484    }
485    #[doc = "Peripheral is released from reset"]
486    #[inline(always)]
487    pub fn enabled(self) -> &'a mut crate::W<REG> {
488        self.variant(Opamp1::Enabled)
489    }
490}
491#[doc = "OPAMP2\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Opamp2 {
495    #[doc = "0: Peripheral is held in reset"]
496    Disabled = 0,
497    #[doc = "1: Peripheral is released from reset"]
498    Enabled = 1,
499}
500impl From<Opamp2> for bool {
501    #[inline(always)]
502    fn from(variant: Opamp2) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `OPAMP2` reader - OPAMP2"]
507pub type Opamp2R = crate::BitReader<Opamp2>;
508impl Opamp2R {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Opamp2 {
512        match self.bits {
513            false => Opamp2::Disabled,
514            true => Opamp2::Enabled,
515        }
516    }
517    #[doc = "Peripheral is held in reset"]
518    #[inline(always)]
519    pub fn is_disabled(&self) -> bool {
520        *self == Opamp2::Disabled
521    }
522    #[doc = "Peripheral is released from reset"]
523    #[inline(always)]
524    pub fn is_enabled(&self) -> bool {
525        *self == Opamp2::Enabled
526    }
527}
528#[doc = "Field `OPAMP2` writer - OPAMP2"]
529pub type Opamp2W<'a, REG> = crate::BitWriter<'a, REG, Opamp2>;
530impl<'a, REG> Opamp2W<'a, REG>
531where
532    REG: crate::Writable + crate::RegisterSpec,
533{
534    #[doc = "Peripheral is held in reset"]
535    #[inline(always)]
536    pub fn disabled(self) -> &'a mut crate::W<REG> {
537        self.variant(Opamp2::Disabled)
538    }
539    #[doc = "Peripheral is released from reset"]
540    #[inline(always)]
541    pub fn enabled(self) -> &'a mut crate::W<REG> {
542        self.variant(Opamp2::Enabled)
543    }
544}
545#[doc = "OPAMP3\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Opamp3 {
549    #[doc = "0: Peripheral is held in reset"]
550    Disabled = 0,
551    #[doc = "1: Peripheral is released from reset"]
552    Enabled = 1,
553}
554impl From<Opamp3> for bool {
555    #[inline(always)]
556    fn from(variant: Opamp3) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `OPAMP3` reader - OPAMP3"]
561pub type Opamp3R = crate::BitReader<Opamp3>;
562impl Opamp3R {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Opamp3 {
566        match self.bits {
567            false => Opamp3::Disabled,
568            true => Opamp3::Enabled,
569        }
570    }
571    #[doc = "Peripheral is held in reset"]
572    #[inline(always)]
573    pub fn is_disabled(&self) -> bool {
574        *self == Opamp3::Disabled
575    }
576    #[doc = "Peripheral is released from reset"]
577    #[inline(always)]
578    pub fn is_enabled(&self) -> bool {
579        *self == Opamp3::Enabled
580    }
581}
582#[doc = "Field `OPAMP3` writer - OPAMP3"]
583pub type Opamp3W<'a, REG> = crate::BitWriter<'a, REG, Opamp3>;
584impl<'a, REG> Opamp3W<'a, REG>
585where
586    REG: crate::Writable + crate::RegisterSpec,
587{
588    #[doc = "Peripheral is held in reset"]
589    #[inline(always)]
590    pub fn disabled(self) -> &'a mut crate::W<REG> {
591        self.variant(Opamp3::Disabled)
592    }
593    #[doc = "Peripheral is released from reset"]
594    #[inline(always)]
595    pub fn enabled(self) -> &'a mut crate::W<REG> {
596        self.variant(Opamp3::Enabled)
597    }
598}
599#[doc = "PORT0\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum Port0 {
603    #[doc = "0: Peripheral is held in reset"]
604    Disabled = 0,
605    #[doc = "1: Peripheral is released from reset"]
606    Enabled = 1,
607}
608impl From<Port0> for bool {
609    #[inline(always)]
610    fn from(variant: Port0) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `PORT0` reader - PORT0"]
615pub type Port0R = crate::BitReader<Port0>;
616impl Port0R {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Port0 {
620        match self.bits {
621            false => Port0::Disabled,
622            true => Port0::Enabled,
623        }
624    }
625    #[doc = "Peripheral is held in reset"]
626    #[inline(always)]
627    pub fn is_disabled(&self) -> bool {
628        *self == Port0::Disabled
629    }
630    #[doc = "Peripheral is released from reset"]
631    #[inline(always)]
632    pub fn is_enabled(&self) -> bool {
633        *self == Port0::Enabled
634    }
635}
636#[doc = "Field `PORT0` writer - PORT0"]
637pub type Port0W<'a, REG> = crate::BitWriter<'a, REG, Port0>;
638impl<'a, REG> Port0W<'a, REG>
639where
640    REG: crate::Writable + crate::RegisterSpec,
641{
642    #[doc = "Peripheral is held in reset"]
643    #[inline(always)]
644    pub fn disabled(self) -> &'a mut crate::W<REG> {
645        self.variant(Port0::Disabled)
646    }
647    #[doc = "Peripheral is released from reset"]
648    #[inline(always)]
649    pub fn enabled(self) -> &'a mut crate::W<REG> {
650        self.variant(Port0::Enabled)
651    }
652}
653#[doc = "PORT1\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Port1 {
657    #[doc = "0: Peripheral is held in reset"]
658    Disabled = 0,
659    #[doc = "1: Peripheral is released from reset"]
660    Enabled = 1,
661}
662impl From<Port1> for bool {
663    #[inline(always)]
664    fn from(variant: Port1) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `PORT1` reader - PORT1"]
669pub type Port1R = crate::BitReader<Port1>;
670impl Port1R {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Port1 {
674        match self.bits {
675            false => Port1::Disabled,
676            true => Port1::Enabled,
677        }
678    }
679    #[doc = "Peripheral is held in reset"]
680    #[inline(always)]
681    pub fn is_disabled(&self) -> bool {
682        *self == Port1::Disabled
683    }
684    #[doc = "Peripheral is released from reset"]
685    #[inline(always)]
686    pub fn is_enabled(&self) -> bool {
687        *self == Port1::Enabled
688    }
689}
690#[doc = "Field `PORT1` writer - PORT1"]
691pub type Port1W<'a, REG> = crate::BitWriter<'a, REG, Port1>;
692impl<'a, REG> Port1W<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "Peripheral is held in reset"]
697    #[inline(always)]
698    pub fn disabled(self) -> &'a mut crate::W<REG> {
699        self.variant(Port1::Disabled)
700    }
701    #[doc = "Peripheral is released from reset"]
702    #[inline(always)]
703    pub fn enabled(self) -> &'a mut crate::W<REG> {
704        self.variant(Port1::Enabled)
705    }
706}
707#[doc = "PORT2\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Port2 {
711    #[doc = "0: Peripheral is held in reset"]
712    Disabled = 0,
713    #[doc = "1: Peripheral is released from reset"]
714    Enabled = 1,
715}
716impl From<Port2> for bool {
717    #[inline(always)]
718    fn from(variant: Port2) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `PORT2` reader - PORT2"]
723pub type Port2R = crate::BitReader<Port2>;
724impl Port2R {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Port2 {
728        match self.bits {
729            false => Port2::Disabled,
730            true => Port2::Enabled,
731        }
732    }
733    #[doc = "Peripheral is held in reset"]
734    #[inline(always)]
735    pub fn is_disabled(&self) -> bool {
736        *self == Port2::Disabled
737    }
738    #[doc = "Peripheral is released from reset"]
739    #[inline(always)]
740    pub fn is_enabled(&self) -> bool {
741        *self == Port2::Enabled
742    }
743}
744#[doc = "Field `PORT2` writer - PORT2"]
745pub type Port2W<'a, REG> = crate::BitWriter<'a, REG, Port2>;
746impl<'a, REG> Port2W<'a, REG>
747where
748    REG: crate::Writable + crate::RegisterSpec,
749{
750    #[doc = "Peripheral is held in reset"]
751    #[inline(always)]
752    pub fn disabled(self) -> &'a mut crate::W<REG> {
753        self.variant(Port2::Disabled)
754    }
755    #[doc = "Peripheral is released from reset"]
756    #[inline(always)]
757    pub fn enabled(self) -> &'a mut crate::W<REG> {
758        self.variant(Port2::Enabled)
759    }
760}
761#[doc = "PORT3\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Port3 {
765    #[doc = "0: Peripheral is held in reset"]
766    Disabled = 0,
767    #[doc = "1: Peripheral is released from reset"]
768    Enabled = 1,
769}
770impl From<Port3> for bool {
771    #[inline(always)]
772    fn from(variant: Port3) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `PORT3` reader - PORT3"]
777pub type Port3R = crate::BitReader<Port3>;
778impl Port3R {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> Port3 {
782        match self.bits {
783            false => Port3::Disabled,
784            true => Port3::Enabled,
785        }
786    }
787    #[doc = "Peripheral is held in reset"]
788    #[inline(always)]
789    pub fn is_disabled(&self) -> bool {
790        *self == Port3::Disabled
791    }
792    #[doc = "Peripheral is released from reset"]
793    #[inline(always)]
794    pub fn is_enabled(&self) -> bool {
795        *self == Port3::Enabled
796    }
797}
798#[doc = "Field `PORT3` writer - PORT3"]
799pub type Port3W<'a, REG> = crate::BitWriter<'a, REG, Port3>;
800impl<'a, REG> Port3W<'a, REG>
801where
802    REG: crate::Writable + crate::RegisterSpec,
803{
804    #[doc = "Peripheral is held in reset"]
805    #[inline(always)]
806    pub fn disabled(self) -> &'a mut crate::W<REG> {
807        self.variant(Port3::Disabled)
808    }
809    #[doc = "Peripheral is released from reset"]
810    #[inline(always)]
811    pub fn enabled(self) -> &'a mut crate::W<REG> {
812        self.variant(Port3::Enabled)
813    }
814}
815#[doc = "PORT4\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Port4 {
819    #[doc = "0: Peripheral is held in reset"]
820    Disabled = 0,
821    #[doc = "1: Peripheral is released from reset"]
822    Enabled = 1,
823}
824impl From<Port4> for bool {
825    #[inline(always)]
826    fn from(variant: Port4) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `PORT4` reader - PORT4"]
831pub type Port4R = crate::BitReader<Port4>;
832impl Port4R {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> Port4 {
836        match self.bits {
837            false => Port4::Disabled,
838            true => Port4::Enabled,
839        }
840    }
841    #[doc = "Peripheral is held in reset"]
842    #[inline(always)]
843    pub fn is_disabled(&self) -> bool {
844        *self == Port4::Disabled
845    }
846    #[doc = "Peripheral is released from reset"]
847    #[inline(always)]
848    pub fn is_enabled(&self) -> bool {
849        *self == Port4::Enabled
850    }
851}
852#[doc = "Field `PORT4` writer - PORT4"]
853pub type Port4W<'a, REG> = crate::BitWriter<'a, REG, Port4>;
854impl<'a, REG> Port4W<'a, REG>
855where
856    REG: crate::Writable + crate::RegisterSpec,
857{
858    #[doc = "Peripheral is held in reset"]
859    #[inline(always)]
860    pub fn disabled(self) -> &'a mut crate::W<REG> {
861        self.variant(Port4::Disabled)
862    }
863    #[doc = "Peripheral is released from reset"]
864    #[inline(always)]
865    pub fn enabled(self) -> &'a mut crate::W<REG> {
866        self.variant(Port4::Enabled)
867    }
868}
869#[doc = "SLCD0\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Slcd0 {
873    #[doc = "0: Peripheral is held in reset"]
874    Disabled = 0,
875    #[doc = "1: Peripheral is released from reset"]
876    Enabled = 1,
877}
878impl From<Slcd0> for bool {
879    #[inline(always)]
880    fn from(variant: Slcd0) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `SLCD0` reader - SLCD0"]
885pub type Slcd0R = crate::BitReader<Slcd0>;
886impl Slcd0R {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> Slcd0 {
890        match self.bits {
891            false => Slcd0::Disabled,
892            true => Slcd0::Enabled,
893        }
894    }
895    #[doc = "Peripheral is held in reset"]
896    #[inline(always)]
897    pub fn is_disabled(&self) -> bool {
898        *self == Slcd0::Disabled
899    }
900    #[doc = "Peripheral is released from reset"]
901    #[inline(always)]
902    pub fn is_enabled(&self) -> bool {
903        *self == Slcd0::Enabled
904    }
905}
906#[doc = "Field `SLCD0` writer - SLCD0"]
907pub type Slcd0W<'a, REG> = crate::BitWriter<'a, REG, Slcd0>;
908impl<'a, REG> Slcd0W<'a, REG>
909where
910    REG: crate::Writable + crate::RegisterSpec,
911{
912    #[doc = "Peripheral is held in reset"]
913    #[inline(always)]
914    pub fn disabled(self) -> &'a mut crate::W<REG> {
915        self.variant(Slcd0::Disabled)
916    }
917    #[doc = "Peripheral is released from reset"]
918    #[inline(always)]
919    pub fn enabled(self) -> &'a mut crate::W<REG> {
920        self.variant(Slcd0::Enabled)
921    }
922}
923#[doc = "FLEXCAN0\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Flexcan0 {
927    #[doc = "0: Peripheral is held in reset"]
928    Disabled = 0,
929    #[doc = "1: Peripheral is released from reset"]
930    Enabled = 1,
931}
932impl From<Flexcan0> for bool {
933    #[inline(always)]
934    fn from(variant: Flexcan0) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `FLEXCAN0` reader - FLEXCAN0"]
939pub type Flexcan0R = crate::BitReader<Flexcan0>;
940impl Flexcan0R {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> Flexcan0 {
944        match self.bits {
945            false => Flexcan0::Disabled,
946            true => Flexcan0::Enabled,
947        }
948    }
949    #[doc = "Peripheral is held in reset"]
950    #[inline(always)]
951    pub fn is_disabled(&self) -> bool {
952        *self == Flexcan0::Disabled
953    }
954    #[doc = "Peripheral is released from reset"]
955    #[inline(always)]
956    pub fn is_enabled(&self) -> bool {
957        *self == Flexcan0::Enabled
958    }
959}
960#[doc = "Field `FLEXCAN0` writer - FLEXCAN0"]
961pub type Flexcan0W<'a, REG> = crate::BitWriter<'a, REG, Flexcan0>;
962impl<'a, REG> Flexcan0W<'a, REG>
963where
964    REG: crate::Writable + crate::RegisterSpec,
965{
966    #[doc = "Peripheral is held in reset"]
967    #[inline(always)]
968    pub fn disabled(self) -> &'a mut crate::W<REG> {
969        self.variant(Flexcan0::Disabled)
970    }
971    #[doc = "Peripheral is released from reset"]
972    #[inline(always)]
973    pub fn enabled(self) -> &'a mut crate::W<REG> {
974        self.variant(Flexcan0::Enabled)
975    }
976}
977#[doc = "FLEXCAN1\n\nValue on reset: 0"]
978#[cfg_attr(feature = "defmt", derive(defmt::Format))]
979#[derive(Clone, Copy, Debug, PartialEq, Eq)]
980pub enum Flexcan1 {
981    #[doc = "0: Peripheral is held in reset"]
982    Disabled = 0,
983    #[doc = "1: Peripheral is released from reset"]
984    Enabled = 1,
985}
986impl From<Flexcan1> for bool {
987    #[inline(always)]
988    fn from(variant: Flexcan1) -> Self {
989        variant as u8 != 0
990    }
991}
992#[doc = "Field `FLEXCAN1` reader - FLEXCAN1"]
993pub type Flexcan1R = crate::BitReader<Flexcan1>;
994impl Flexcan1R {
995    #[doc = "Get enumerated values variant"]
996    #[inline(always)]
997    pub const fn variant(&self) -> Flexcan1 {
998        match self.bits {
999            false => Flexcan1::Disabled,
1000            true => Flexcan1::Enabled,
1001        }
1002    }
1003    #[doc = "Peripheral is held in reset"]
1004    #[inline(always)]
1005    pub fn is_disabled(&self) -> bool {
1006        *self == Flexcan1::Disabled
1007    }
1008    #[doc = "Peripheral is released from reset"]
1009    #[inline(always)]
1010    pub fn is_enabled(&self) -> bool {
1011        *self == Flexcan1::Enabled
1012    }
1013}
1014#[doc = "Field `FLEXCAN1` writer - FLEXCAN1"]
1015pub type Flexcan1W<'a, REG> = crate::BitWriter<'a, REG, Flexcan1>;
1016impl<'a, REG> Flexcan1W<'a, REG>
1017where
1018    REG: crate::Writable + crate::RegisterSpec,
1019{
1020    #[doc = "Peripheral is held in reset"]
1021    #[inline(always)]
1022    pub fn disabled(self) -> &'a mut crate::W<REG> {
1023        self.variant(Flexcan1::Disabled)
1024    }
1025    #[doc = "Peripheral is released from reset"]
1026    #[inline(always)]
1027    pub fn enabled(self) -> &'a mut crate::W<REG> {
1028        self.variant(Flexcan1::Enabled)
1029    }
1030}
1031#[doc = "LPI2C2\n\nValue on reset: 0"]
1032#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1033#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1034pub enum Lpi2c2 {
1035    #[doc = "0: Peripheral is held in reset"]
1036    Disabled = 0,
1037    #[doc = "1: Peripheral is released from reset"]
1038    Enabled = 1,
1039}
1040impl From<Lpi2c2> for bool {
1041    #[inline(always)]
1042    fn from(variant: Lpi2c2) -> Self {
1043        variant as u8 != 0
1044    }
1045}
1046#[doc = "Field `LPI2C2` reader - LPI2C2"]
1047pub type Lpi2c2R = crate::BitReader<Lpi2c2>;
1048impl Lpi2c2R {
1049    #[doc = "Get enumerated values variant"]
1050    #[inline(always)]
1051    pub const fn variant(&self) -> Lpi2c2 {
1052        match self.bits {
1053            false => Lpi2c2::Disabled,
1054            true => Lpi2c2::Enabled,
1055        }
1056    }
1057    #[doc = "Peripheral is held in reset"]
1058    #[inline(always)]
1059    pub fn is_disabled(&self) -> bool {
1060        *self == Lpi2c2::Disabled
1061    }
1062    #[doc = "Peripheral is released from reset"]
1063    #[inline(always)]
1064    pub fn is_enabled(&self) -> bool {
1065        *self == Lpi2c2::Enabled
1066    }
1067}
1068#[doc = "Field `LPI2C2` writer - LPI2C2"]
1069pub type Lpi2c2W<'a, REG> = crate::BitWriter<'a, REG, Lpi2c2>;
1070impl<'a, REG> Lpi2c2W<'a, REG>
1071where
1072    REG: crate::Writable + crate::RegisterSpec,
1073{
1074    #[doc = "Peripheral is held in reset"]
1075    #[inline(always)]
1076    pub fn disabled(self) -> &'a mut crate::W<REG> {
1077        self.variant(Lpi2c2::Disabled)
1078    }
1079    #[doc = "Peripheral is released from reset"]
1080    #[inline(always)]
1081    pub fn enabled(self) -> &'a mut crate::W<REG> {
1082        self.variant(Lpi2c2::Enabled)
1083    }
1084}
1085#[doc = "LPI2C3\n\nValue on reset: 0"]
1086#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1087#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1088pub enum Lpi2c3 {
1089    #[doc = "0: Peripheral is held in reset"]
1090    Disabled = 0,
1091    #[doc = "1: Peripheral is released from reset"]
1092    Enabled = 1,
1093}
1094impl From<Lpi2c3> for bool {
1095    #[inline(always)]
1096    fn from(variant: Lpi2c3) -> Self {
1097        variant as u8 != 0
1098    }
1099}
1100#[doc = "Field `LPI2C3` reader - LPI2C3"]
1101pub type Lpi2c3R = crate::BitReader<Lpi2c3>;
1102impl Lpi2c3R {
1103    #[doc = "Get enumerated values variant"]
1104    #[inline(always)]
1105    pub const fn variant(&self) -> Lpi2c3 {
1106        match self.bits {
1107            false => Lpi2c3::Disabled,
1108            true => Lpi2c3::Enabled,
1109        }
1110    }
1111    #[doc = "Peripheral is held in reset"]
1112    #[inline(always)]
1113    pub fn is_disabled(&self) -> bool {
1114        *self == Lpi2c3::Disabled
1115    }
1116    #[doc = "Peripheral is released from reset"]
1117    #[inline(always)]
1118    pub fn is_enabled(&self) -> bool {
1119        *self == Lpi2c3::Enabled
1120    }
1121}
1122#[doc = "Field `LPI2C3` writer - LPI2C3"]
1123pub type Lpi2c3W<'a, REG> = crate::BitWriter<'a, REG, Lpi2c3>;
1124impl<'a, REG> Lpi2c3W<'a, REG>
1125where
1126    REG: crate::Writable + crate::RegisterSpec,
1127{
1128    #[doc = "Peripheral is held in reset"]
1129    #[inline(always)]
1130    pub fn disabled(self) -> &'a mut crate::W<REG> {
1131        self.variant(Lpi2c3::Disabled)
1132    }
1133    #[doc = "Peripheral is released from reset"]
1134    #[inline(always)]
1135    pub fn enabled(self) -> &'a mut crate::W<REG> {
1136        self.variant(Lpi2c3::Enabled)
1137    }
1138}
1139#[doc = "LPUART5\n\nValue on reset: 0"]
1140#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1142pub enum Lpuart5 {
1143    #[doc = "0: Peripheral is held in reset"]
1144    Disabled = 0,
1145    #[doc = "1: Peripheral is released from reset"]
1146    Enabled = 1,
1147}
1148impl From<Lpuart5> for bool {
1149    #[inline(always)]
1150    fn from(variant: Lpuart5) -> Self {
1151        variant as u8 != 0
1152    }
1153}
1154#[doc = "Field `LPUART5` reader - LPUART5"]
1155pub type Lpuart5R = crate::BitReader<Lpuart5>;
1156impl Lpuart5R {
1157    #[doc = "Get enumerated values variant"]
1158    #[inline(always)]
1159    pub const fn variant(&self) -> Lpuart5 {
1160        match self.bits {
1161            false => Lpuart5::Disabled,
1162            true => Lpuart5::Enabled,
1163        }
1164    }
1165    #[doc = "Peripheral is held in reset"]
1166    #[inline(always)]
1167    pub fn is_disabled(&self) -> bool {
1168        *self == Lpuart5::Disabled
1169    }
1170    #[doc = "Peripheral is released from reset"]
1171    #[inline(always)]
1172    pub fn is_enabled(&self) -> bool {
1173        *self == Lpuart5::Enabled
1174    }
1175}
1176#[doc = "Field `LPUART5` writer - LPUART5"]
1177pub type Lpuart5W<'a, REG> = crate::BitWriter<'a, REG, Lpuart5>;
1178impl<'a, REG> Lpuart5W<'a, REG>
1179where
1180    REG: crate::Writable + crate::RegisterSpec,
1181{
1182    #[doc = "Peripheral is held in reset"]
1183    #[inline(always)]
1184    pub fn disabled(self) -> &'a mut crate::W<REG> {
1185        self.variant(Lpuart5::Disabled)
1186    }
1187    #[doc = "Peripheral is released from reset"]
1188    #[inline(always)]
1189    pub fn enabled(self) -> &'a mut crate::W<REG> {
1190        self.variant(Lpuart5::Enabled)
1191    }
1192}
1193#[doc = "PKC0\n\nValue on reset: 0"]
1194#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1195#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1196pub enum Pkc0 {
1197    #[doc = "0: Peripheral is held in reset"]
1198    Disabled = 0,
1199    #[doc = "1: Peripheral is released from reset"]
1200    Enabled = 1,
1201}
1202impl From<Pkc0> for bool {
1203    #[inline(always)]
1204    fn from(variant: Pkc0) -> Self {
1205        variant as u8 != 0
1206    }
1207}
1208#[doc = "Field `PKC0` reader - PKC0"]
1209pub type Pkc0R = crate::BitReader<Pkc0>;
1210impl Pkc0R {
1211    #[doc = "Get enumerated values variant"]
1212    #[inline(always)]
1213    pub const fn variant(&self) -> Pkc0 {
1214        match self.bits {
1215            false => Pkc0::Disabled,
1216            true => Pkc0::Enabled,
1217        }
1218    }
1219    #[doc = "Peripheral is held in reset"]
1220    #[inline(always)]
1221    pub fn is_disabled(&self) -> bool {
1222        *self == Pkc0::Disabled
1223    }
1224    #[doc = "Peripheral is released from reset"]
1225    #[inline(always)]
1226    pub fn is_enabled(&self) -> bool {
1227        *self == Pkc0::Enabled
1228    }
1229}
1230#[doc = "Field `PKC0` writer - PKC0"]
1231pub type Pkc0W<'a, REG> = crate::BitWriter<'a, REG, Pkc0>;
1232impl<'a, REG> Pkc0W<'a, REG>
1233where
1234    REG: crate::Writable + crate::RegisterSpec,
1235{
1236    #[doc = "Peripheral is held in reset"]
1237    #[inline(always)]
1238    pub fn disabled(self) -> &'a mut crate::W<REG> {
1239        self.variant(Pkc0::Disabled)
1240    }
1241    #[doc = "Peripheral is released from reset"]
1242    #[inline(always)]
1243    pub fn enabled(self) -> &'a mut crate::W<REG> {
1244        self.variant(Pkc0::Enabled)
1245    }
1246}
1247#[doc = "TRNG0\n\nValue on reset: 0"]
1248#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1249#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1250pub enum Trng0 {
1251    #[doc = "0: Peripheral is held in reset"]
1252    Disabled = 0,
1253    #[doc = "1: Peripheral is released from reset"]
1254    Enabled = 1,
1255}
1256impl From<Trng0> for bool {
1257    #[inline(always)]
1258    fn from(variant: Trng0) -> Self {
1259        variant as u8 != 0
1260    }
1261}
1262#[doc = "Field `TRNG0` reader - TRNG0"]
1263pub type Trng0R = crate::BitReader<Trng0>;
1264impl Trng0R {
1265    #[doc = "Get enumerated values variant"]
1266    #[inline(always)]
1267    pub const fn variant(&self) -> Trng0 {
1268        match self.bits {
1269            false => Trng0::Disabled,
1270            true => Trng0::Enabled,
1271        }
1272    }
1273    #[doc = "Peripheral is held in reset"]
1274    #[inline(always)]
1275    pub fn is_disabled(&self) -> bool {
1276        *self == Trng0::Disabled
1277    }
1278    #[doc = "Peripheral is released from reset"]
1279    #[inline(always)]
1280    pub fn is_enabled(&self) -> bool {
1281        *self == Trng0::Enabled
1282    }
1283}
1284#[doc = "Field `TRNG0` writer - TRNG0"]
1285pub type Trng0W<'a, REG> = crate::BitWriter<'a, REG, Trng0>;
1286impl<'a, REG> Trng0W<'a, REG>
1287where
1288    REG: crate::Writable + crate::RegisterSpec,
1289{
1290    #[doc = "Peripheral is held in reset"]
1291    #[inline(always)]
1292    pub fn disabled(self) -> &'a mut crate::W<REG> {
1293        self.variant(Trng0::Disabled)
1294    }
1295    #[doc = "Peripheral is released from reset"]
1296    #[inline(always)]
1297    pub fn enabled(self) -> &'a mut crate::W<REG> {
1298        self.variant(Trng0::Enabled)
1299    }
1300}
1301#[doc = "ADC2\n\nValue on reset: 0"]
1302#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1303#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1304pub enum Adc2 {
1305    #[doc = "0: Peripheral is held in reset"]
1306    Disabled = 0,
1307    #[doc = "1: Peripheral is released from reset"]
1308    Enabled = 1,
1309}
1310impl From<Adc2> for bool {
1311    #[inline(always)]
1312    fn from(variant: Adc2) -> Self {
1313        variant as u8 != 0
1314    }
1315}
1316#[doc = "Field `ADC2` reader - ADC2"]
1317pub type Adc2R = crate::BitReader<Adc2>;
1318impl Adc2R {
1319    #[doc = "Get enumerated values variant"]
1320    #[inline(always)]
1321    pub const fn variant(&self) -> Adc2 {
1322        match self.bits {
1323            false => Adc2::Disabled,
1324            true => Adc2::Enabled,
1325        }
1326    }
1327    #[doc = "Peripheral is held in reset"]
1328    #[inline(always)]
1329    pub fn is_disabled(&self) -> bool {
1330        *self == Adc2::Disabled
1331    }
1332    #[doc = "Peripheral is released from reset"]
1333    #[inline(always)]
1334    pub fn is_enabled(&self) -> bool {
1335        *self == Adc2::Enabled
1336    }
1337}
1338#[doc = "Field `ADC2` writer - ADC2"]
1339pub type Adc2W<'a, REG> = crate::BitWriter<'a, REG, Adc2>;
1340impl<'a, REG> Adc2W<'a, REG>
1341where
1342    REG: crate::Writable + crate::RegisterSpec,
1343{
1344    #[doc = "Peripheral is held in reset"]
1345    #[inline(always)]
1346    pub fn disabled(self) -> &'a mut crate::W<REG> {
1347        self.variant(Adc2::Disabled)
1348    }
1349    #[doc = "Peripheral is released from reset"]
1350    #[inline(always)]
1351    pub fn enabled(self) -> &'a mut crate::W<REG> {
1352        self.variant(Adc2::Enabled)
1353    }
1354}
1355#[doc = "ADC3\n\nValue on reset: 0"]
1356#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1357#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1358pub enum Adc3 {
1359    #[doc = "0: Peripheral is held in reset"]
1360    Disabled = 0,
1361    #[doc = "1: Peripheral is released from reset"]
1362    Enabled = 1,
1363}
1364impl From<Adc3> for bool {
1365    #[inline(always)]
1366    fn from(variant: Adc3) -> Self {
1367        variant as u8 != 0
1368    }
1369}
1370#[doc = "Field `ADC3` reader - ADC3"]
1371pub type Adc3R = crate::BitReader<Adc3>;
1372impl Adc3R {
1373    #[doc = "Get enumerated values variant"]
1374    #[inline(always)]
1375    pub const fn variant(&self) -> Adc3 {
1376        match self.bits {
1377            false => Adc3::Disabled,
1378            true => Adc3::Enabled,
1379        }
1380    }
1381    #[doc = "Peripheral is held in reset"]
1382    #[inline(always)]
1383    pub fn is_disabled(&self) -> bool {
1384        *self == Adc3::Disabled
1385    }
1386    #[doc = "Peripheral is released from reset"]
1387    #[inline(always)]
1388    pub fn is_enabled(&self) -> bool {
1389        *self == Adc3::Enabled
1390    }
1391}
1392#[doc = "Field `ADC3` writer - ADC3"]
1393pub type Adc3W<'a, REG> = crate::BitWriter<'a, REG, Adc3>;
1394impl<'a, REG> Adc3W<'a, REG>
1395where
1396    REG: crate::Writable + crate::RegisterSpec,
1397{
1398    #[doc = "Peripheral is held in reset"]
1399    #[inline(always)]
1400    pub fn disabled(self) -> &'a mut crate::W<REG> {
1401        self.variant(Adc3::Disabled)
1402    }
1403    #[doc = "Peripheral is released from reset"]
1404    #[inline(always)]
1405    pub fn enabled(self) -> &'a mut crate::W<REG> {
1406        self.variant(Adc3::Enabled)
1407    }
1408}
1409impl R {
1410    #[doc = "Bit 0 - FLEXPWM1"]
1411    #[inline(always)]
1412    pub fn flexpwm1(&self) -> Flexpwm1R {
1413        Flexpwm1R::new((self.bits & 1) != 0)
1414    }
1415    #[doc = "Bit 1 - OSTIMER0"]
1416    #[inline(always)]
1417    pub fn ostimer0(&self) -> Ostimer0R {
1418        Ostimer0R::new(((self.bits >> 1) & 1) != 0)
1419    }
1420    #[doc = "Bit 2 - ADC0"]
1421    #[inline(always)]
1422    pub fn adc0(&self) -> Adc0R {
1423        Adc0R::new(((self.bits >> 2) & 1) != 0)
1424    }
1425    #[doc = "Bit 3 - ADC1"]
1426    #[inline(always)]
1427    pub fn adc1(&self) -> Adc1R {
1428        Adc1R::new(((self.bits >> 3) & 1) != 0)
1429    }
1430    #[doc = "Bit 5 - CMP1"]
1431    #[inline(always)]
1432    pub fn cmp1(&self) -> Cmp1R {
1433        Cmp1R::new(((self.bits >> 5) & 1) != 0)
1434    }
1435    #[doc = "Bit 6 - CMP2"]
1436    #[inline(always)]
1437    pub fn cmp2(&self) -> Cmp2R {
1438        Cmp2R::new(((self.bits >> 6) & 1) != 0)
1439    }
1440    #[doc = "Bit 7 - DAC0"]
1441    #[inline(always)]
1442    pub fn dac0(&self) -> Dac0R {
1443        Dac0R::new(((self.bits >> 7) & 1) != 0)
1444    }
1445    #[doc = "Bit 8 - OPAMP0"]
1446    #[inline(always)]
1447    pub fn opamp0(&self) -> Opamp0R {
1448        Opamp0R::new(((self.bits >> 8) & 1) != 0)
1449    }
1450    #[doc = "Bit 9 - OPAMP1"]
1451    #[inline(always)]
1452    pub fn opamp1(&self) -> Opamp1R {
1453        Opamp1R::new(((self.bits >> 9) & 1) != 0)
1454    }
1455    #[doc = "Bit 10 - OPAMP2"]
1456    #[inline(always)]
1457    pub fn opamp2(&self) -> Opamp2R {
1458        Opamp2R::new(((self.bits >> 10) & 1) != 0)
1459    }
1460    #[doc = "Bit 11 - OPAMP3"]
1461    #[inline(always)]
1462    pub fn opamp3(&self) -> Opamp3R {
1463        Opamp3R::new(((self.bits >> 11) & 1) != 0)
1464    }
1465    #[doc = "Bit 12 - PORT0"]
1466    #[inline(always)]
1467    pub fn port0(&self) -> Port0R {
1468        Port0R::new(((self.bits >> 12) & 1) != 0)
1469    }
1470    #[doc = "Bit 13 - PORT1"]
1471    #[inline(always)]
1472    pub fn port1(&self) -> Port1R {
1473        Port1R::new(((self.bits >> 13) & 1) != 0)
1474    }
1475    #[doc = "Bit 14 - PORT2"]
1476    #[inline(always)]
1477    pub fn port2(&self) -> Port2R {
1478        Port2R::new(((self.bits >> 14) & 1) != 0)
1479    }
1480    #[doc = "Bit 15 - PORT3"]
1481    #[inline(always)]
1482    pub fn port3(&self) -> Port3R {
1483        Port3R::new(((self.bits >> 15) & 1) != 0)
1484    }
1485    #[doc = "Bit 16 - PORT4"]
1486    #[inline(always)]
1487    pub fn port4(&self) -> Port4R {
1488        Port4R::new(((self.bits >> 16) & 1) != 0)
1489    }
1490    #[doc = "Bit 17 - SLCD0"]
1491    #[inline(always)]
1492    pub fn slcd0(&self) -> Slcd0R {
1493        Slcd0R::new(((self.bits >> 17) & 1) != 0)
1494    }
1495    #[doc = "Bit 18 - FLEXCAN0"]
1496    #[inline(always)]
1497    pub fn flexcan0(&self) -> Flexcan0R {
1498        Flexcan0R::new(((self.bits >> 18) & 1) != 0)
1499    }
1500    #[doc = "Bit 19 - FLEXCAN1"]
1501    #[inline(always)]
1502    pub fn flexcan1(&self) -> Flexcan1R {
1503        Flexcan1R::new(((self.bits >> 19) & 1) != 0)
1504    }
1505    #[doc = "Bit 20 - LPI2C2"]
1506    #[inline(always)]
1507    pub fn lpi2c2(&self) -> Lpi2c2R {
1508        Lpi2c2R::new(((self.bits >> 20) & 1) != 0)
1509    }
1510    #[doc = "Bit 21 - LPI2C3"]
1511    #[inline(always)]
1512    pub fn lpi2c3(&self) -> Lpi2c3R {
1513        Lpi2c3R::new(((self.bits >> 21) & 1) != 0)
1514    }
1515    #[doc = "Bit 22 - LPUART5"]
1516    #[inline(always)]
1517    pub fn lpuart5(&self) -> Lpuart5R {
1518        Lpuart5R::new(((self.bits >> 22) & 1) != 0)
1519    }
1520    #[doc = "Bit 24 - PKC0"]
1521    #[inline(always)]
1522    pub fn pkc0(&self) -> Pkc0R {
1523        Pkc0R::new(((self.bits >> 24) & 1) != 0)
1524    }
1525    #[doc = "Bit 26 - TRNG0"]
1526    #[inline(always)]
1527    pub fn trng0(&self) -> Trng0R {
1528        Trng0R::new(((self.bits >> 26) & 1) != 0)
1529    }
1530    #[doc = "Bit 28 - ADC2"]
1531    #[inline(always)]
1532    pub fn adc2(&self) -> Adc2R {
1533        Adc2R::new(((self.bits >> 28) & 1) != 0)
1534    }
1535    #[doc = "Bit 29 - ADC3"]
1536    #[inline(always)]
1537    pub fn adc3(&self) -> Adc3R {
1538        Adc3R::new(((self.bits >> 29) & 1) != 0)
1539    }
1540}
1541#[cfg(feature = "debug")]
1542impl core::fmt::Debug for R {
1543    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1544        f.debug_struct("MRCC_GLB_RST1")
1545            .field("flexpwm1", &self.flexpwm1())
1546            .field("ostimer0", &self.ostimer0())
1547            .field("adc0", &self.adc0())
1548            .field("adc1", &self.adc1())
1549            .field("cmp1", &self.cmp1())
1550            .field("cmp2", &self.cmp2())
1551            .field("dac0", &self.dac0())
1552            .field("opamp0", &self.opamp0())
1553            .field("opamp1", &self.opamp1())
1554            .field("opamp2", &self.opamp2())
1555            .field("opamp3", &self.opamp3())
1556            .field("port0", &self.port0())
1557            .field("port1", &self.port1())
1558            .field("port2", &self.port2())
1559            .field("port3", &self.port3())
1560            .field("port4", &self.port4())
1561            .field("slcd0", &self.slcd0())
1562            .field("flexcan0", &self.flexcan0())
1563            .field("flexcan1", &self.flexcan1())
1564            .field("lpi2c2", &self.lpi2c2())
1565            .field("lpi2c3", &self.lpi2c3())
1566            .field("lpuart5", &self.lpuart5())
1567            .field("pkc0", &self.pkc0())
1568            .field("trng0", &self.trng0())
1569            .field("adc2", &self.adc2())
1570            .field("adc3", &self.adc3())
1571            .finish()
1572    }
1573}
1574impl W {
1575    #[doc = "Bit 0 - FLEXPWM1"]
1576    #[inline(always)]
1577    pub fn flexpwm1(&mut self) -> Flexpwm1W<'_, MrccGlbRst1Spec> {
1578        Flexpwm1W::new(self, 0)
1579    }
1580    #[doc = "Bit 1 - OSTIMER0"]
1581    #[inline(always)]
1582    pub fn ostimer0(&mut self) -> Ostimer0W<'_, MrccGlbRst1Spec> {
1583        Ostimer0W::new(self, 1)
1584    }
1585    #[doc = "Bit 2 - ADC0"]
1586    #[inline(always)]
1587    pub fn adc0(&mut self) -> Adc0W<'_, MrccGlbRst1Spec> {
1588        Adc0W::new(self, 2)
1589    }
1590    #[doc = "Bit 3 - ADC1"]
1591    #[inline(always)]
1592    pub fn adc1(&mut self) -> Adc1W<'_, MrccGlbRst1Spec> {
1593        Adc1W::new(self, 3)
1594    }
1595    #[doc = "Bit 5 - CMP1"]
1596    #[inline(always)]
1597    pub fn cmp1(&mut self) -> Cmp1W<'_, MrccGlbRst1Spec> {
1598        Cmp1W::new(self, 5)
1599    }
1600    #[doc = "Bit 6 - CMP2"]
1601    #[inline(always)]
1602    pub fn cmp2(&mut self) -> Cmp2W<'_, MrccGlbRst1Spec> {
1603        Cmp2W::new(self, 6)
1604    }
1605    #[doc = "Bit 7 - DAC0"]
1606    #[inline(always)]
1607    pub fn dac0(&mut self) -> Dac0W<'_, MrccGlbRst1Spec> {
1608        Dac0W::new(self, 7)
1609    }
1610    #[doc = "Bit 8 - OPAMP0"]
1611    #[inline(always)]
1612    pub fn opamp0(&mut self) -> Opamp0W<'_, MrccGlbRst1Spec> {
1613        Opamp0W::new(self, 8)
1614    }
1615    #[doc = "Bit 9 - OPAMP1"]
1616    #[inline(always)]
1617    pub fn opamp1(&mut self) -> Opamp1W<'_, MrccGlbRst1Spec> {
1618        Opamp1W::new(self, 9)
1619    }
1620    #[doc = "Bit 10 - OPAMP2"]
1621    #[inline(always)]
1622    pub fn opamp2(&mut self) -> Opamp2W<'_, MrccGlbRst1Spec> {
1623        Opamp2W::new(self, 10)
1624    }
1625    #[doc = "Bit 11 - OPAMP3"]
1626    #[inline(always)]
1627    pub fn opamp3(&mut self) -> Opamp3W<'_, MrccGlbRst1Spec> {
1628        Opamp3W::new(self, 11)
1629    }
1630    #[doc = "Bit 12 - PORT0"]
1631    #[inline(always)]
1632    pub fn port0(&mut self) -> Port0W<'_, MrccGlbRst1Spec> {
1633        Port0W::new(self, 12)
1634    }
1635    #[doc = "Bit 13 - PORT1"]
1636    #[inline(always)]
1637    pub fn port1(&mut self) -> Port1W<'_, MrccGlbRst1Spec> {
1638        Port1W::new(self, 13)
1639    }
1640    #[doc = "Bit 14 - PORT2"]
1641    #[inline(always)]
1642    pub fn port2(&mut self) -> Port2W<'_, MrccGlbRst1Spec> {
1643        Port2W::new(self, 14)
1644    }
1645    #[doc = "Bit 15 - PORT3"]
1646    #[inline(always)]
1647    pub fn port3(&mut self) -> Port3W<'_, MrccGlbRst1Spec> {
1648        Port3W::new(self, 15)
1649    }
1650    #[doc = "Bit 16 - PORT4"]
1651    #[inline(always)]
1652    pub fn port4(&mut self) -> Port4W<'_, MrccGlbRst1Spec> {
1653        Port4W::new(self, 16)
1654    }
1655    #[doc = "Bit 17 - SLCD0"]
1656    #[inline(always)]
1657    pub fn slcd0(&mut self) -> Slcd0W<'_, MrccGlbRst1Spec> {
1658        Slcd0W::new(self, 17)
1659    }
1660    #[doc = "Bit 18 - FLEXCAN0"]
1661    #[inline(always)]
1662    pub fn flexcan0(&mut self) -> Flexcan0W<'_, MrccGlbRst1Spec> {
1663        Flexcan0W::new(self, 18)
1664    }
1665    #[doc = "Bit 19 - FLEXCAN1"]
1666    #[inline(always)]
1667    pub fn flexcan1(&mut self) -> Flexcan1W<'_, MrccGlbRst1Spec> {
1668        Flexcan1W::new(self, 19)
1669    }
1670    #[doc = "Bit 20 - LPI2C2"]
1671    #[inline(always)]
1672    pub fn lpi2c2(&mut self) -> Lpi2c2W<'_, MrccGlbRst1Spec> {
1673        Lpi2c2W::new(self, 20)
1674    }
1675    #[doc = "Bit 21 - LPI2C3"]
1676    #[inline(always)]
1677    pub fn lpi2c3(&mut self) -> Lpi2c3W<'_, MrccGlbRst1Spec> {
1678        Lpi2c3W::new(self, 21)
1679    }
1680    #[doc = "Bit 22 - LPUART5"]
1681    #[inline(always)]
1682    pub fn lpuart5(&mut self) -> Lpuart5W<'_, MrccGlbRst1Spec> {
1683        Lpuart5W::new(self, 22)
1684    }
1685    #[doc = "Bit 24 - PKC0"]
1686    #[inline(always)]
1687    pub fn pkc0(&mut self) -> Pkc0W<'_, MrccGlbRst1Spec> {
1688        Pkc0W::new(self, 24)
1689    }
1690    #[doc = "Bit 26 - TRNG0"]
1691    #[inline(always)]
1692    pub fn trng0(&mut self) -> Trng0W<'_, MrccGlbRst1Spec> {
1693        Trng0W::new(self, 26)
1694    }
1695    #[doc = "Bit 28 - ADC2"]
1696    #[inline(always)]
1697    pub fn adc2(&mut self) -> Adc2W<'_, MrccGlbRst1Spec> {
1698        Adc2W::new(self, 28)
1699    }
1700    #[doc = "Bit 29 - ADC3"]
1701    #[inline(always)]
1702    pub fn adc3(&mut self) -> Adc3W<'_, MrccGlbRst1Spec> {
1703        Adc3W::new(self, 29)
1704    }
1705}
1706#[doc = "Peripheral Reset Control 1\n\nYou can [`read`](crate::Reg::read) this register and get [`mrcc_glb_rst1::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`mrcc_glb_rst1::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1707pub struct MrccGlbRst1Spec;
1708impl crate::RegisterSpec for MrccGlbRst1Spec {
1709    type Ux = u32;
1710}
1711#[doc = "`read()` method returns [`mrcc_glb_rst1::R`](R) reader structure"]
1712impl crate::Readable for MrccGlbRst1Spec {}
1713#[doc = "`write(|w| ..)` method takes [`mrcc_glb_rst1::W`](W) writer structure"]
1714impl crate::Writable for MrccGlbRst1Spec {
1715    type Safety = crate::Unsafe;
1716}
1717#[doc = "`reset()` method sets MRCC_GLB_RST1 to value 0"]
1718impl crate::Resettable for MrccGlbRst1Spec {}
mcxa_pac/mrcc0/mrcc_glb_rst1.rs

mcxa_pac/mrcc0/
mrcc_glb_rst1.rs
