mimxrt685s_pac/sysctl0/
starten0.rs

1#[doc = "Register `STARTEN0` reader"]
2pub type R = crate::R<Starten0Spec>;
3#[doc = "Register `STARTEN0` writer"]
4pub type W = crate::W<Starten0Spec>;
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 Wdt0 {
9    #[doc = "0: disbale"]
10    Disabled = 0,
11    #[doc = "1: enable"]
12    Enabled = 1,
13}
14impl From<Wdt0> for bool {
15    #[inline(always)]
16    fn from(variant: Wdt0) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `WDT0` reader - no description available"]
21pub type Wdt0R = crate::BitReader<Wdt0>;
22impl Wdt0R {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Wdt0 {
26        match self.bits {
27            false => Wdt0::Disabled,
28            true => Wdt0::Enabled,
29        }
30    }
31    #[doc = "disbale"]
32    #[inline(always)]
33    pub fn is_disabled(&self) -> bool {
34        *self == Wdt0::Disabled
35    }
36    #[doc = "enable"]
37    #[inline(always)]
38    pub fn is_enabled(&self) -> bool {
39        *self == Wdt0::Enabled
40    }
41}
42#[doc = "Field `WDT0` writer - no description available"]
43pub type Wdt0W<'a, REG> = crate::BitWriter<'a, REG, Wdt0>;
44impl<'a, REG> Wdt0W<'a, REG>
45where
46    REG: crate::Writable + crate::RegisterSpec,
47{
48    #[doc = "disbale"]
49    #[inline(always)]
50    pub fn disabled(self) -> &'a mut crate::W<REG> {
51        self.variant(Wdt0::Disabled)
52    }
53    #[doc = "enable"]
54    #[inline(always)]
55    pub fn enabled(self) -> &'a mut crate::W<REG> {
56        self.variant(Wdt0::Enabled)
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 Dmac0 {
63    #[doc = "0: disbale"]
64    Disabled = 0,
65    #[doc = "1: enable"]
66    Enabled = 1,
67}
68impl From<Dmac0> for bool {
69    #[inline(always)]
70    fn from(variant: Dmac0) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `DMAC0` reader - no description available"]
75pub type Dmac0R = crate::BitReader<Dmac0>;
76impl Dmac0R {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Dmac0 {
80        match self.bits {
81            false => Dmac0::Disabled,
82            true => Dmac0::Enabled,
83        }
84    }
85    #[doc = "disbale"]
86    #[inline(always)]
87    pub fn is_disabled(&self) -> bool {
88        *self == Dmac0::Disabled
89    }
90    #[doc = "enable"]
91    #[inline(always)]
92    pub fn is_enabled(&self) -> bool {
93        *self == Dmac0::Enabled
94    }
95}
96#[doc = "Field `DMAC0` writer - no description available"]
97pub type Dmac0W<'a, REG> = crate::BitWriter<'a, REG, Dmac0>;
98impl<'a, REG> Dmac0W<'a, REG>
99where
100    REG: crate::Writable + crate::RegisterSpec,
101{
102    #[doc = "disbale"]
103    #[inline(always)]
104    pub fn disabled(self) -> &'a mut crate::W<REG> {
105        self.variant(Dmac0::Disabled)
106    }
107    #[doc = "enable"]
108    #[inline(always)]
109    pub fn enabled(self) -> &'a mut crate::W<REG> {
110        self.variant(Dmac0::Enabled)
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 NshsgpioInt0 {
117    #[doc = "0: disbale"]
118    Disabled = 0,
119    #[doc = "1: enable"]
120    Enabled = 1,
121}
122impl From<NshsgpioInt0> for bool {
123    #[inline(always)]
124    fn from(variant: NshsgpioInt0) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `NSHSGPIO_INT0` reader - no description available"]
129pub type NshsgpioInt0R = crate::BitReader<NshsgpioInt0>;
130impl NshsgpioInt0R {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> NshsgpioInt0 {
134        match self.bits {
135            false => NshsgpioInt0::Disabled,
136            true => NshsgpioInt0::Enabled,
137        }
138    }
139    #[doc = "disbale"]
140    #[inline(always)]
141    pub fn is_disabled(&self) -> bool {
142        *self == NshsgpioInt0::Disabled
143    }
144    #[doc = "enable"]
145    #[inline(always)]
146    pub fn is_enabled(&self) -> bool {
147        *self == NshsgpioInt0::Enabled
148    }
149}
150#[doc = "Field `NSHSGPIO_INT0` writer - no description available"]
151pub type NshsgpioInt0W<'a, REG> = crate::BitWriter<'a, REG, NshsgpioInt0>;
152impl<'a, REG> NshsgpioInt0W<'a, REG>
153where
154    REG: crate::Writable + crate::RegisterSpec,
155{
156    #[doc = "disbale"]
157    #[inline(always)]
158    pub fn disabled(self) -> &'a mut crate::W<REG> {
159        self.variant(NshsgpioInt0::Disabled)
160    }
161    #[doc = "enable"]
162    #[inline(always)]
163    pub fn enabled(self) -> &'a mut crate::W<REG> {
164        self.variant(NshsgpioInt0::Enabled)
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 NshsgpioInt1 {
171    #[doc = "0: disbale"]
172    Disabled = 0,
173    #[doc = "1: enable"]
174    Enabled = 1,
175}
176impl From<NshsgpioInt1> for bool {
177    #[inline(always)]
178    fn from(variant: NshsgpioInt1) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `NSHSGPIO_INT1` reader - no description available"]
183pub type NshsgpioInt1R = crate::BitReader<NshsgpioInt1>;
184impl NshsgpioInt1R {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> NshsgpioInt1 {
188        match self.bits {
189            false => NshsgpioInt1::Disabled,
190            true => NshsgpioInt1::Enabled,
191        }
192    }
193    #[doc = "disbale"]
194    #[inline(always)]
195    pub fn is_disabled(&self) -> bool {
196        *self == NshsgpioInt1::Disabled
197    }
198    #[doc = "enable"]
199    #[inline(always)]
200    pub fn is_enabled(&self) -> bool {
201        *self == NshsgpioInt1::Enabled
202    }
203}
204#[doc = "Field `NSHSGPIO_INT1` writer - no description available"]
205pub type NshsgpioInt1W<'a, REG> = crate::BitWriter<'a, REG, NshsgpioInt1>;
206impl<'a, REG> NshsgpioInt1W<'a, REG>
207where
208    REG: crate::Writable + crate::RegisterSpec,
209{
210    #[doc = "disbale"]
211    #[inline(always)]
212    pub fn disabled(self) -> &'a mut crate::W<REG> {
213        self.variant(NshsgpioInt1::Disabled)
214    }
215    #[doc = "enable"]
216    #[inline(always)]
217    pub fn enabled(self) -> &'a mut crate::W<REG> {
218        self.variant(NshsgpioInt1::Enabled)
219    }
220}
221#[doc = "no description available\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum GpioInt0Irq0 {
225    #[doc = "0: disbale"]
226    Disabled = 0,
227    #[doc = "1: enable"]
228    Enabled = 1,
229}
230impl From<GpioInt0Irq0> for bool {
231    #[inline(always)]
232    fn from(variant: GpioInt0Irq0) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `GPIO_INT0_IRQ0` reader - no description available"]
237pub type GpioInt0Irq0R = crate::BitReader<GpioInt0Irq0>;
238impl GpioInt0Irq0R {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> GpioInt0Irq0 {
242        match self.bits {
243            false => GpioInt0Irq0::Disabled,
244            true => GpioInt0Irq0::Enabled,
245        }
246    }
247    #[doc = "disbale"]
248    #[inline(always)]
249    pub fn is_disabled(&self) -> bool {
250        *self == GpioInt0Irq0::Disabled
251    }
252    #[doc = "enable"]
253    #[inline(always)]
254    pub fn is_enabled(&self) -> bool {
255        *self == GpioInt0Irq0::Enabled
256    }
257}
258#[doc = "Field `GPIO_INT0_IRQ0` writer - no description available"]
259pub type GpioInt0Irq0W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq0>;
260impl<'a, REG> GpioInt0Irq0W<'a, REG>
261where
262    REG: crate::Writable + crate::RegisterSpec,
263{
264    #[doc = "disbale"]
265    #[inline(always)]
266    pub fn disabled(self) -> &'a mut crate::W<REG> {
267        self.variant(GpioInt0Irq0::Disabled)
268    }
269    #[doc = "enable"]
270    #[inline(always)]
271    pub fn enabled(self) -> &'a mut crate::W<REG> {
272        self.variant(GpioInt0Irq0::Enabled)
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 GpioInt0Irq1 {
279    #[doc = "0: disbale"]
280    Disabled = 0,
281    #[doc = "1: enable"]
282    Enabled = 1,
283}
284impl From<GpioInt0Irq1> for bool {
285    #[inline(always)]
286    fn from(variant: GpioInt0Irq1) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `GPIO_INT0_IRQ1` reader - no description available"]
291pub type GpioInt0Irq1R = crate::BitReader<GpioInt0Irq1>;
292impl GpioInt0Irq1R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> GpioInt0Irq1 {
296        match self.bits {
297            false => GpioInt0Irq1::Disabled,
298            true => GpioInt0Irq1::Enabled,
299        }
300    }
301    #[doc = "disbale"]
302    #[inline(always)]
303    pub fn is_disabled(&self) -> bool {
304        *self == GpioInt0Irq1::Disabled
305    }
306    #[doc = "enable"]
307    #[inline(always)]
308    pub fn is_enabled(&self) -> bool {
309        *self == GpioInt0Irq1::Enabled
310    }
311}
312#[doc = "Field `GPIO_INT0_IRQ1` writer - no description available"]
313pub type GpioInt0Irq1W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq1>;
314impl<'a, REG> GpioInt0Irq1W<'a, REG>
315where
316    REG: crate::Writable + crate::RegisterSpec,
317{
318    #[doc = "disbale"]
319    #[inline(always)]
320    pub fn disabled(self) -> &'a mut crate::W<REG> {
321        self.variant(GpioInt0Irq1::Disabled)
322    }
323    #[doc = "enable"]
324    #[inline(always)]
325    pub fn enabled(self) -> &'a mut crate::W<REG> {
326        self.variant(GpioInt0Irq1::Enabled)
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 GpioInt0Irq2 {
333    #[doc = "0: disbale"]
334    Disabled = 0,
335    #[doc = "1: enable"]
336    Enabled = 1,
337}
338impl From<GpioInt0Irq2> for bool {
339    #[inline(always)]
340    fn from(variant: GpioInt0Irq2) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `GPIO_INT0_IRQ2` reader - no description available"]
345pub type GpioInt0Irq2R = crate::BitReader<GpioInt0Irq2>;
346impl GpioInt0Irq2R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> GpioInt0Irq2 {
350        match self.bits {
351            false => GpioInt0Irq2::Disabled,
352            true => GpioInt0Irq2::Enabled,
353        }
354    }
355    #[doc = "disbale"]
356    #[inline(always)]
357    pub fn is_disabled(&self) -> bool {
358        *self == GpioInt0Irq2::Disabled
359    }
360    #[doc = "enable"]
361    #[inline(always)]
362    pub fn is_enabled(&self) -> bool {
363        *self == GpioInt0Irq2::Enabled
364    }
365}
366#[doc = "Field `GPIO_INT0_IRQ2` writer - no description available"]
367pub type GpioInt0Irq2W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq2>;
368impl<'a, REG> GpioInt0Irq2W<'a, REG>
369where
370    REG: crate::Writable + crate::RegisterSpec,
371{
372    #[doc = "disbale"]
373    #[inline(always)]
374    pub fn disabled(self) -> &'a mut crate::W<REG> {
375        self.variant(GpioInt0Irq2::Disabled)
376    }
377    #[doc = "enable"]
378    #[inline(always)]
379    pub fn enabled(self) -> &'a mut crate::W<REG> {
380        self.variant(GpioInt0Irq2::Enabled)
381    }
382}
383#[doc = "no description available\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum GpioInt0Irq3 {
387    #[doc = "0: disbale"]
388    Disabled = 0,
389    #[doc = "1: enable"]
390    Enabled = 1,
391}
392impl From<GpioInt0Irq3> for bool {
393    #[inline(always)]
394    fn from(variant: GpioInt0Irq3) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `GPIO_INT0_IRQ3` reader - no description available"]
399pub type GpioInt0Irq3R = crate::BitReader<GpioInt0Irq3>;
400impl GpioInt0Irq3R {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> GpioInt0Irq3 {
404        match self.bits {
405            false => GpioInt0Irq3::Disabled,
406            true => GpioInt0Irq3::Enabled,
407        }
408    }
409    #[doc = "disbale"]
410    #[inline(always)]
411    pub fn is_disabled(&self) -> bool {
412        *self == GpioInt0Irq3::Disabled
413    }
414    #[doc = "enable"]
415    #[inline(always)]
416    pub fn is_enabled(&self) -> bool {
417        *self == GpioInt0Irq3::Enabled
418    }
419}
420#[doc = "Field `GPIO_INT0_IRQ3` writer - no description available"]
421pub type GpioInt0Irq3W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq3>;
422impl<'a, REG> GpioInt0Irq3W<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "disbale"]
427    #[inline(always)]
428    pub fn disabled(self) -> &'a mut crate::W<REG> {
429        self.variant(GpioInt0Irq3::Disabled)
430    }
431    #[doc = "enable"]
432    #[inline(always)]
433    pub fn enabled(self) -> &'a mut crate::W<REG> {
434        self.variant(GpioInt0Irq3::Enabled)
435    }
436}
437#[doc = "no description available\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Utick0 {
441    #[doc = "0: disbale"]
442    Disabled = 0,
443    #[doc = "1: enable"]
444    Enabled = 1,
445}
446impl From<Utick0> for bool {
447    #[inline(always)]
448    fn from(variant: Utick0) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `UTICK0` reader - no description available"]
453pub type Utick0R = crate::BitReader<Utick0>;
454impl Utick0R {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> Utick0 {
458        match self.bits {
459            false => Utick0::Disabled,
460            true => Utick0::Enabled,
461        }
462    }
463    #[doc = "disbale"]
464    #[inline(always)]
465    pub fn is_disabled(&self) -> bool {
466        *self == Utick0::Disabled
467    }
468    #[doc = "enable"]
469    #[inline(always)]
470    pub fn is_enabled(&self) -> bool {
471        *self == Utick0::Enabled
472    }
473}
474#[doc = "Field `UTICK0` writer - no description available"]
475pub type Utick0W<'a, REG> = crate::BitWriter<'a, REG, Utick0>;
476impl<'a, REG> Utick0W<'a, REG>
477where
478    REG: crate::Writable + crate::RegisterSpec,
479{
480    #[doc = "disbale"]
481    #[inline(always)]
482    pub fn disabled(self) -> &'a mut crate::W<REG> {
483        self.variant(Utick0::Disabled)
484    }
485    #[doc = "enable"]
486    #[inline(always)]
487    pub fn enabled(self) -> &'a mut crate::W<REG> {
488        self.variant(Utick0::Enabled)
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 Mrt0 {
495    #[doc = "0: disbale"]
496    Disabled = 0,
497    #[doc = "1: enable"]
498    Enabled = 1,
499}
500impl From<Mrt0> for bool {
501    #[inline(always)]
502    fn from(variant: Mrt0) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `MRT0` reader - no description available"]
507pub type Mrt0R = crate::BitReader<Mrt0>;
508impl Mrt0R {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Mrt0 {
512        match self.bits {
513            false => Mrt0::Disabled,
514            true => Mrt0::Enabled,
515        }
516    }
517    #[doc = "disbale"]
518    #[inline(always)]
519    pub fn is_disabled(&self) -> bool {
520        *self == Mrt0::Disabled
521    }
522    #[doc = "enable"]
523    #[inline(always)]
524    pub fn is_enabled(&self) -> bool {
525        *self == Mrt0::Enabled
526    }
527}
528#[doc = "Field `MRT0` writer - no description available"]
529pub type Mrt0W<'a, REG> = crate::BitWriter<'a, REG, Mrt0>;
530impl<'a, REG> Mrt0W<'a, REG>
531where
532    REG: crate::Writable + crate::RegisterSpec,
533{
534    #[doc = "disbale"]
535    #[inline(always)]
536    pub fn disabled(self) -> &'a mut crate::W<REG> {
537        self.variant(Mrt0::Disabled)
538    }
539    #[doc = "enable"]
540    #[inline(always)]
541    pub fn enabled(self) -> &'a mut crate::W<REG> {
542        self.variant(Mrt0::Enabled)
543    }
544}
545#[doc = "no description available\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Ct32bit0 {
549    #[doc = "0: disbale"]
550    Disabled = 0,
551    #[doc = "1: enable"]
552    Enabled = 1,
553}
554impl From<Ct32bit0> for bool {
555    #[inline(always)]
556    fn from(variant: Ct32bit0) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `CT32BIT0` reader - no description available"]
561pub type Ct32bit0R = crate::BitReader<Ct32bit0>;
562impl Ct32bit0R {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Ct32bit0 {
566        match self.bits {
567            false => Ct32bit0::Disabled,
568            true => Ct32bit0::Enabled,
569        }
570    }
571    #[doc = "disbale"]
572    #[inline(always)]
573    pub fn is_disabled(&self) -> bool {
574        *self == Ct32bit0::Disabled
575    }
576    #[doc = "enable"]
577    #[inline(always)]
578    pub fn is_enabled(&self) -> bool {
579        *self == Ct32bit0::Enabled
580    }
581}
582#[doc = "Field `CT32BIT0` writer - no description available"]
583pub type Ct32bit0W<'a, REG> = crate::BitWriter<'a, REG, Ct32bit0>;
584impl<'a, REG> Ct32bit0W<'a, REG>
585where
586    REG: crate::Writable + crate::RegisterSpec,
587{
588    #[doc = "disbale"]
589    #[inline(always)]
590    pub fn disabled(self) -> &'a mut crate::W<REG> {
591        self.variant(Ct32bit0::Disabled)
592    }
593    #[doc = "enable"]
594    #[inline(always)]
595    pub fn enabled(self) -> &'a mut crate::W<REG> {
596        self.variant(Ct32bit0::Enabled)
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 Ct32bit1 {
603    #[doc = "0: disbale"]
604    Disabled = 0,
605    #[doc = "1: enable"]
606    Enabled = 1,
607}
608impl From<Ct32bit1> for bool {
609    #[inline(always)]
610    fn from(variant: Ct32bit1) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `CT32BIT1` reader - no description available"]
615pub type Ct32bit1R = crate::BitReader<Ct32bit1>;
616impl Ct32bit1R {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Ct32bit1 {
620        match self.bits {
621            false => Ct32bit1::Disabled,
622            true => Ct32bit1::Enabled,
623        }
624    }
625    #[doc = "disbale"]
626    #[inline(always)]
627    pub fn is_disabled(&self) -> bool {
628        *self == Ct32bit1::Disabled
629    }
630    #[doc = "enable"]
631    #[inline(always)]
632    pub fn is_enabled(&self) -> bool {
633        *self == Ct32bit1::Enabled
634    }
635}
636#[doc = "Field `CT32BIT1` writer - no description available"]
637pub type Ct32bit1W<'a, REG> = crate::BitWriter<'a, REG, Ct32bit1>;
638impl<'a, REG> Ct32bit1W<'a, REG>
639where
640    REG: crate::Writable + crate::RegisterSpec,
641{
642    #[doc = "disbale"]
643    #[inline(always)]
644    pub fn disabled(self) -> &'a mut crate::W<REG> {
645        self.variant(Ct32bit1::Disabled)
646    }
647    #[doc = "enable"]
648    #[inline(always)]
649    pub fn enabled(self) -> &'a mut crate::W<REG> {
650        self.variant(Ct32bit1::Enabled)
651    }
652}
653#[doc = "no description available\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Sct0 {
657    #[doc = "0: disbale"]
658    Disabled = 0,
659    #[doc = "1: enable"]
660    Enabled = 1,
661}
662impl From<Sct0> for bool {
663    #[inline(always)]
664    fn from(variant: Sct0) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `SCT0` reader - no description available"]
669pub type Sct0R = crate::BitReader<Sct0>;
670impl Sct0R {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Sct0 {
674        match self.bits {
675            false => Sct0::Disabled,
676            true => Sct0::Enabled,
677        }
678    }
679    #[doc = "disbale"]
680    #[inline(always)]
681    pub fn is_disabled(&self) -> bool {
682        *self == Sct0::Disabled
683    }
684    #[doc = "enable"]
685    #[inline(always)]
686    pub fn is_enabled(&self) -> bool {
687        *self == Sct0::Enabled
688    }
689}
690#[doc = "Field `SCT0` writer - no description available"]
691pub type Sct0W<'a, REG> = crate::BitWriter<'a, REG, Sct0>;
692impl<'a, REG> Sct0W<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "disbale"]
697    #[inline(always)]
698    pub fn disabled(self) -> &'a mut crate::W<REG> {
699        self.variant(Sct0::Disabled)
700    }
701    #[doc = "enable"]
702    #[inline(always)]
703    pub fn enabled(self) -> &'a mut crate::W<REG> {
704        self.variant(Sct0::Enabled)
705    }
706}
707#[doc = "no description available\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Ct32bit3 {
711    #[doc = "0: disbale"]
712    Disabled = 0,
713    #[doc = "1: enable"]
714    Enabled = 1,
715}
716impl From<Ct32bit3> for bool {
717    #[inline(always)]
718    fn from(variant: Ct32bit3) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `CT32BIT3` reader - no description available"]
723pub type Ct32bit3R = crate::BitReader<Ct32bit3>;
724impl Ct32bit3R {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Ct32bit3 {
728        match self.bits {
729            false => Ct32bit3::Disabled,
730            true => Ct32bit3::Enabled,
731        }
732    }
733    #[doc = "disbale"]
734    #[inline(always)]
735    pub fn is_disabled(&self) -> bool {
736        *self == Ct32bit3::Disabled
737    }
738    #[doc = "enable"]
739    #[inline(always)]
740    pub fn is_enabled(&self) -> bool {
741        *self == Ct32bit3::Enabled
742    }
743}
744#[doc = "Field `CT32BIT3` writer - no description available"]
745pub type Ct32bit3W<'a, REG> = crate::BitWriter<'a, REG, Ct32bit3>;
746impl<'a, REG> Ct32bit3W<'a, REG>
747where
748    REG: crate::Writable + crate::RegisterSpec,
749{
750    #[doc = "disbale"]
751    #[inline(always)]
752    pub fn disabled(self) -> &'a mut crate::W<REG> {
753        self.variant(Ct32bit3::Disabled)
754    }
755    #[doc = "enable"]
756    #[inline(always)]
757    pub fn enabled(self) -> &'a mut crate::W<REG> {
758        self.variant(Ct32bit3::Enabled)
759    }
760}
761#[doc = "no description available\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Flexcomm0 {
765    #[doc = "0: disbale"]
766    Disabled = 0,
767    #[doc = "1: enable"]
768    Enabled = 1,
769}
770impl From<Flexcomm0> for bool {
771    #[inline(always)]
772    fn from(variant: Flexcomm0) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `FLEXCOMM0` reader - no description available"]
777pub type Flexcomm0R = crate::BitReader<Flexcomm0>;
778impl Flexcomm0R {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> Flexcomm0 {
782        match self.bits {
783            false => Flexcomm0::Disabled,
784            true => Flexcomm0::Enabled,
785        }
786    }
787    #[doc = "disbale"]
788    #[inline(always)]
789    pub fn is_disabled(&self) -> bool {
790        *self == Flexcomm0::Disabled
791    }
792    #[doc = "enable"]
793    #[inline(always)]
794    pub fn is_enabled(&self) -> bool {
795        *self == Flexcomm0::Enabled
796    }
797}
798#[doc = "Field `FLEXCOMM0` writer - no description available"]
799pub type Flexcomm0W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm0>;
800impl<'a, REG> Flexcomm0W<'a, REG>
801where
802    REG: crate::Writable + crate::RegisterSpec,
803{
804    #[doc = "disbale"]
805    #[inline(always)]
806    pub fn disabled(self) -> &'a mut crate::W<REG> {
807        self.variant(Flexcomm0::Disabled)
808    }
809    #[doc = "enable"]
810    #[inline(always)]
811    pub fn enabled(self) -> &'a mut crate::W<REG> {
812        self.variant(Flexcomm0::Enabled)
813    }
814}
815#[doc = "no description available\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Flexcomm1 {
819    #[doc = "0: disbale"]
820    Disabled = 0,
821    #[doc = "1: enable"]
822    Enabled = 1,
823}
824impl From<Flexcomm1> for bool {
825    #[inline(always)]
826    fn from(variant: Flexcomm1) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `FLEXCOMM1` reader - no description available"]
831pub type Flexcomm1R = crate::BitReader<Flexcomm1>;
832impl Flexcomm1R {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> Flexcomm1 {
836        match self.bits {
837            false => Flexcomm1::Disabled,
838            true => Flexcomm1::Enabled,
839        }
840    }
841    #[doc = "disbale"]
842    #[inline(always)]
843    pub fn is_disabled(&self) -> bool {
844        *self == Flexcomm1::Disabled
845    }
846    #[doc = "enable"]
847    #[inline(always)]
848    pub fn is_enabled(&self) -> bool {
849        *self == Flexcomm1::Enabled
850    }
851}
852#[doc = "Field `FLEXCOMM1` writer - no description available"]
853pub type Flexcomm1W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm1>;
854impl<'a, REG> Flexcomm1W<'a, REG>
855where
856    REG: crate::Writable + crate::RegisterSpec,
857{
858    #[doc = "disbale"]
859    #[inline(always)]
860    pub fn disabled(self) -> &'a mut crate::W<REG> {
861        self.variant(Flexcomm1::Disabled)
862    }
863    #[doc = "enable"]
864    #[inline(always)]
865    pub fn enabled(self) -> &'a mut crate::W<REG> {
866        self.variant(Flexcomm1::Enabled)
867    }
868}
869#[doc = "no description available\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Flexcomm2 {
873    #[doc = "0: disbale"]
874    Disabled = 0,
875    #[doc = "1: enable"]
876    Enabled = 1,
877}
878impl From<Flexcomm2> for bool {
879    #[inline(always)]
880    fn from(variant: Flexcomm2) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `FLEXCOMM2` reader - no description available"]
885pub type Flexcomm2R = crate::BitReader<Flexcomm2>;
886impl Flexcomm2R {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> Flexcomm2 {
890        match self.bits {
891            false => Flexcomm2::Disabled,
892            true => Flexcomm2::Enabled,
893        }
894    }
895    #[doc = "disbale"]
896    #[inline(always)]
897    pub fn is_disabled(&self) -> bool {
898        *self == Flexcomm2::Disabled
899    }
900    #[doc = "enable"]
901    #[inline(always)]
902    pub fn is_enabled(&self) -> bool {
903        *self == Flexcomm2::Enabled
904    }
905}
906#[doc = "Field `FLEXCOMM2` writer - no description available"]
907pub type Flexcomm2W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm2>;
908impl<'a, REG> Flexcomm2W<'a, REG>
909where
910    REG: crate::Writable + crate::RegisterSpec,
911{
912    #[doc = "disbale"]
913    #[inline(always)]
914    pub fn disabled(self) -> &'a mut crate::W<REG> {
915        self.variant(Flexcomm2::Disabled)
916    }
917    #[doc = "enable"]
918    #[inline(always)]
919    pub fn enabled(self) -> &'a mut crate::W<REG> {
920        self.variant(Flexcomm2::Enabled)
921    }
922}
923#[doc = "no description available\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Flexcomm3 {
927    #[doc = "0: disbale"]
928    Disabled = 0,
929    #[doc = "1: enable"]
930    Enabled = 1,
931}
932impl From<Flexcomm3> for bool {
933    #[inline(always)]
934    fn from(variant: Flexcomm3) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `FLEXCOMM3` reader - no description available"]
939pub type Flexcomm3R = crate::BitReader<Flexcomm3>;
940impl Flexcomm3R {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> Flexcomm3 {
944        match self.bits {
945            false => Flexcomm3::Disabled,
946            true => Flexcomm3::Enabled,
947        }
948    }
949    #[doc = "disbale"]
950    #[inline(always)]
951    pub fn is_disabled(&self) -> bool {
952        *self == Flexcomm3::Disabled
953    }
954    #[doc = "enable"]
955    #[inline(always)]
956    pub fn is_enabled(&self) -> bool {
957        *self == Flexcomm3::Enabled
958    }
959}
960#[doc = "Field `FLEXCOMM3` writer - no description available"]
961pub type Flexcomm3W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm3>;
962impl<'a, REG> Flexcomm3W<'a, REG>
963where
964    REG: crate::Writable + crate::RegisterSpec,
965{
966    #[doc = "disbale"]
967    #[inline(always)]
968    pub fn disabled(self) -> &'a mut crate::W<REG> {
969        self.variant(Flexcomm3::Disabled)
970    }
971    #[doc = "enable"]
972    #[inline(always)]
973    pub fn enabled(self) -> &'a mut crate::W<REG> {
974        self.variant(Flexcomm3::Enabled)
975    }
976}
977#[doc = "no description available\n\nValue on reset: 0"]
978#[cfg_attr(feature = "defmt", derive(defmt::Format))]
979#[derive(Clone, Copy, Debug, PartialEq, Eq)]
980pub enum Flexcomm4 {
981    #[doc = "0: disbale"]
982    Disabled = 0,
983    #[doc = "1: enable"]
984    Enabled = 1,
985}
986impl From<Flexcomm4> for bool {
987    #[inline(always)]
988    fn from(variant: Flexcomm4) -> Self {
989        variant as u8 != 0
990    }
991}
992#[doc = "Field `FLEXCOMM4` reader - no description available"]
993pub type Flexcomm4R = crate::BitReader<Flexcomm4>;
994impl Flexcomm4R {
995    #[doc = "Get enumerated values variant"]
996    #[inline(always)]
997    pub const fn variant(&self) -> Flexcomm4 {
998        match self.bits {
999            false => Flexcomm4::Disabled,
1000            true => Flexcomm4::Enabled,
1001        }
1002    }
1003    #[doc = "disbale"]
1004    #[inline(always)]
1005    pub fn is_disabled(&self) -> bool {
1006        *self == Flexcomm4::Disabled
1007    }
1008    #[doc = "enable"]
1009    #[inline(always)]
1010    pub fn is_enabled(&self) -> bool {
1011        *self == Flexcomm4::Enabled
1012    }
1013}
1014#[doc = "Field `FLEXCOMM4` writer - no description available"]
1015pub type Flexcomm4W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm4>;
1016impl<'a, REG> Flexcomm4W<'a, REG>
1017where
1018    REG: crate::Writable + crate::RegisterSpec,
1019{
1020    #[doc = "disbale"]
1021    #[inline(always)]
1022    pub fn disabled(self) -> &'a mut crate::W<REG> {
1023        self.variant(Flexcomm4::Disabled)
1024    }
1025    #[doc = "enable"]
1026    #[inline(always)]
1027    pub fn enabled(self) -> &'a mut crate::W<REG> {
1028        self.variant(Flexcomm4::Enabled)
1029    }
1030}
1031#[doc = "no description available\n\nValue on reset: 0"]
1032#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1033#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1034pub enum Flexcomm5 {
1035    #[doc = "0: disbale"]
1036    Disabled = 0,
1037    #[doc = "1: enable"]
1038    Enabled = 1,
1039}
1040impl From<Flexcomm5> for bool {
1041    #[inline(always)]
1042    fn from(variant: Flexcomm5) -> Self {
1043        variant as u8 != 0
1044    }
1045}
1046#[doc = "Field `FLEXCOMM5` reader - no description available"]
1047pub type Flexcomm5R = crate::BitReader<Flexcomm5>;
1048impl Flexcomm5R {
1049    #[doc = "Get enumerated values variant"]
1050    #[inline(always)]
1051    pub const fn variant(&self) -> Flexcomm5 {
1052        match self.bits {
1053            false => Flexcomm5::Disabled,
1054            true => Flexcomm5::Enabled,
1055        }
1056    }
1057    #[doc = "disbale"]
1058    #[inline(always)]
1059    pub fn is_disabled(&self) -> bool {
1060        *self == Flexcomm5::Disabled
1061    }
1062    #[doc = "enable"]
1063    #[inline(always)]
1064    pub fn is_enabled(&self) -> bool {
1065        *self == Flexcomm5::Enabled
1066    }
1067}
1068#[doc = "Field `FLEXCOMM5` writer - no description available"]
1069pub type Flexcomm5W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm5>;
1070impl<'a, REG> Flexcomm5W<'a, REG>
1071where
1072    REG: crate::Writable + crate::RegisterSpec,
1073{
1074    #[doc = "disbale"]
1075    #[inline(always)]
1076    pub fn disabled(self) -> &'a mut crate::W<REG> {
1077        self.variant(Flexcomm5::Disabled)
1078    }
1079    #[doc = "enable"]
1080    #[inline(always)]
1081    pub fn enabled(self) -> &'a mut crate::W<REG> {
1082        self.variant(Flexcomm5::Enabled)
1083    }
1084}
1085#[doc = "no description available\n\nValue on reset: 0"]
1086#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1087#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1088pub enum Flexcomm14 {
1089    #[doc = "0: disbale"]
1090    Disabled = 0,
1091    #[doc = "1: enable"]
1092    Enabled = 1,
1093}
1094impl From<Flexcomm14> for bool {
1095    #[inline(always)]
1096    fn from(variant: Flexcomm14) -> Self {
1097        variant as u8 != 0
1098    }
1099}
1100#[doc = "Field `FLEXCOMM14` reader - no description available"]
1101pub type Flexcomm14R = crate::BitReader<Flexcomm14>;
1102impl Flexcomm14R {
1103    #[doc = "Get enumerated values variant"]
1104    #[inline(always)]
1105    pub const fn variant(&self) -> Flexcomm14 {
1106        match self.bits {
1107            false => Flexcomm14::Disabled,
1108            true => Flexcomm14::Enabled,
1109        }
1110    }
1111    #[doc = "disbale"]
1112    #[inline(always)]
1113    pub fn is_disabled(&self) -> bool {
1114        *self == Flexcomm14::Disabled
1115    }
1116    #[doc = "enable"]
1117    #[inline(always)]
1118    pub fn is_enabled(&self) -> bool {
1119        *self == Flexcomm14::Enabled
1120    }
1121}
1122#[doc = "Field `FLEXCOMM14` writer - no description available"]
1123pub type Flexcomm14W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm14>;
1124impl<'a, REG> Flexcomm14W<'a, REG>
1125where
1126    REG: crate::Writable + crate::RegisterSpec,
1127{
1128    #[doc = "disbale"]
1129    #[inline(always)]
1130    pub fn disabled(self) -> &'a mut crate::W<REG> {
1131        self.variant(Flexcomm14::Disabled)
1132    }
1133    #[doc = "enable"]
1134    #[inline(always)]
1135    pub fn enabled(self) -> &'a mut crate::W<REG> {
1136        self.variant(Flexcomm14::Enabled)
1137    }
1138}
1139#[doc = "no description available\n\nValue on reset: 0"]
1140#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1142pub enum Flexcomm15 {
1143    #[doc = "0: disbale"]
1144    Disabled = 0,
1145    #[doc = "1: enable"]
1146    Enabled = 1,
1147}
1148impl From<Flexcomm15> for bool {
1149    #[inline(always)]
1150    fn from(variant: Flexcomm15) -> Self {
1151        variant as u8 != 0
1152    }
1153}
1154#[doc = "Field `FLEXCOMM15` reader - no description available"]
1155pub type Flexcomm15R = crate::BitReader<Flexcomm15>;
1156impl Flexcomm15R {
1157    #[doc = "Get enumerated values variant"]
1158    #[inline(always)]
1159    pub const fn variant(&self) -> Flexcomm15 {
1160        match self.bits {
1161            false => Flexcomm15::Disabled,
1162            true => Flexcomm15::Enabled,
1163        }
1164    }
1165    #[doc = "disbale"]
1166    #[inline(always)]
1167    pub fn is_disabled(&self) -> bool {
1168        *self == Flexcomm15::Disabled
1169    }
1170    #[doc = "enable"]
1171    #[inline(always)]
1172    pub fn is_enabled(&self) -> bool {
1173        *self == Flexcomm15::Enabled
1174    }
1175}
1176#[doc = "Field `FLEXCOMM15` writer - no description available"]
1177pub type Flexcomm15W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm15>;
1178impl<'a, REG> Flexcomm15W<'a, REG>
1179where
1180    REG: crate::Writable + crate::RegisterSpec,
1181{
1182    #[doc = "disbale"]
1183    #[inline(always)]
1184    pub fn disabled(self) -> &'a mut crate::W<REG> {
1185        self.variant(Flexcomm15::Disabled)
1186    }
1187    #[doc = "enable"]
1188    #[inline(always)]
1189    pub fn enabled(self) -> &'a mut crate::W<REG> {
1190        self.variant(Flexcomm15::Enabled)
1191    }
1192}
1193#[doc = "no description available\n\nValue on reset: 0"]
1194#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1195#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1196pub enum Adc0 {
1197    #[doc = "0: disbale"]
1198    Disabled = 0,
1199    #[doc = "1: enable"]
1200    Enabled = 1,
1201}
1202impl From<Adc0> for bool {
1203    #[inline(always)]
1204    fn from(variant: Adc0) -> Self {
1205        variant as u8 != 0
1206    }
1207}
1208#[doc = "Field `ADC0` reader - no description available"]
1209pub type Adc0R = crate::BitReader<Adc0>;
1210impl Adc0R {
1211    #[doc = "Get enumerated values variant"]
1212    #[inline(always)]
1213    pub const fn variant(&self) -> Adc0 {
1214        match self.bits {
1215            false => Adc0::Disabled,
1216            true => Adc0::Enabled,
1217        }
1218    }
1219    #[doc = "disbale"]
1220    #[inline(always)]
1221    pub fn is_disabled(&self) -> bool {
1222        *self == Adc0::Disabled
1223    }
1224    #[doc = "enable"]
1225    #[inline(always)]
1226    pub fn is_enabled(&self) -> bool {
1227        *self == Adc0::Enabled
1228    }
1229}
1230#[doc = "Field `ADC0` writer - no description available"]
1231pub type Adc0W<'a, REG> = crate::BitWriter<'a, REG, Adc0>;
1232impl<'a, REG> Adc0W<'a, REG>
1233where
1234    REG: crate::Writable + crate::RegisterSpec,
1235{
1236    #[doc = "disbale"]
1237    #[inline(always)]
1238    pub fn disabled(self) -> &'a mut crate::W<REG> {
1239        self.variant(Adc0::Disabled)
1240    }
1241    #[doc = "enable"]
1242    #[inline(always)]
1243    pub fn enabled(self) -> &'a mut crate::W<REG> {
1244        self.variant(Adc0::Enabled)
1245    }
1246}
1247#[doc = "no description available\n\nValue on reset: 0"]
1248#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1249#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1250pub enum Acmp {
1251    #[doc = "0: disbale"]
1252    Disabled = 0,
1253    #[doc = "1: enable"]
1254    Enabled = 1,
1255}
1256impl From<Acmp> for bool {
1257    #[inline(always)]
1258    fn from(variant: Acmp) -> Self {
1259        variant as u8 != 0
1260    }
1261}
1262#[doc = "Field `ACMP` reader - no description available"]
1263pub type AcmpR = crate::BitReader<Acmp>;
1264impl AcmpR {
1265    #[doc = "Get enumerated values variant"]
1266    #[inline(always)]
1267    pub const fn variant(&self) -> Acmp {
1268        match self.bits {
1269            false => Acmp::Disabled,
1270            true => Acmp::Enabled,
1271        }
1272    }
1273    #[doc = "disbale"]
1274    #[inline(always)]
1275    pub fn is_disabled(&self) -> bool {
1276        *self == Acmp::Disabled
1277    }
1278    #[doc = "enable"]
1279    #[inline(always)]
1280    pub fn is_enabled(&self) -> bool {
1281        *self == Acmp::Enabled
1282    }
1283}
1284#[doc = "Field `ACMP` writer - no description available"]
1285pub type AcmpW<'a, REG> = crate::BitWriter<'a, REG, Acmp>;
1286impl<'a, REG> AcmpW<'a, REG>
1287where
1288    REG: crate::Writable + crate::RegisterSpec,
1289{
1290    #[doc = "disbale"]
1291    #[inline(always)]
1292    pub fn disabled(self) -> &'a mut crate::W<REG> {
1293        self.variant(Acmp::Disabled)
1294    }
1295    #[doc = "enable"]
1296    #[inline(always)]
1297    pub fn enabled(self) -> &'a mut crate::W<REG> {
1298        self.variant(Acmp::Enabled)
1299    }
1300}
1301#[doc = "no description available\n\nValue on reset: 0"]
1302#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1303#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1304pub enum Dmic0 {
1305    #[doc = "0: disbale"]
1306    Disabled = 0,
1307    #[doc = "1: enable"]
1308    Enabled = 1,
1309}
1310impl From<Dmic0> for bool {
1311    #[inline(always)]
1312    fn from(variant: Dmic0) -> Self {
1313        variant as u8 != 0
1314    }
1315}
1316#[doc = "Field `DMIC0` reader - no description available"]
1317pub type Dmic0R = crate::BitReader<Dmic0>;
1318impl Dmic0R {
1319    #[doc = "Get enumerated values variant"]
1320    #[inline(always)]
1321    pub const fn variant(&self) -> Dmic0 {
1322        match self.bits {
1323            false => Dmic0::Disabled,
1324            true => Dmic0::Enabled,
1325        }
1326    }
1327    #[doc = "disbale"]
1328    #[inline(always)]
1329    pub fn is_disabled(&self) -> bool {
1330        *self == Dmic0::Disabled
1331    }
1332    #[doc = "enable"]
1333    #[inline(always)]
1334    pub fn is_enabled(&self) -> bool {
1335        *self == Dmic0::Enabled
1336    }
1337}
1338#[doc = "Field `DMIC0` writer - no description available"]
1339pub type Dmic0W<'a, REG> = crate::BitWriter<'a, REG, Dmic0>;
1340impl<'a, REG> Dmic0W<'a, REG>
1341where
1342    REG: crate::Writable + crate::RegisterSpec,
1343{
1344    #[doc = "disbale"]
1345    #[inline(always)]
1346    pub fn disabled(self) -> &'a mut crate::W<REG> {
1347        self.variant(Dmic0::Disabled)
1348    }
1349    #[doc = "enable"]
1350    #[inline(always)]
1351    pub fn enabled(self) -> &'a mut crate::W<REG> {
1352        self.variant(Dmic0::Enabled)
1353    }
1354}
1355#[doc = "no description available\n\nValue on reset: 0"]
1356#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1357#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1358pub enum Hypervisor {
1359    #[doc = "0: disbale"]
1360    Disabled = 0,
1361    #[doc = "1: enable"]
1362    Enabled = 1,
1363}
1364impl From<Hypervisor> for bool {
1365    #[inline(always)]
1366    fn from(variant: Hypervisor) -> Self {
1367        variant as u8 != 0
1368    }
1369}
1370#[doc = "Field `HYPERVISOR` reader - no description available"]
1371pub type HypervisorR = crate::BitReader<Hypervisor>;
1372impl HypervisorR {
1373    #[doc = "Get enumerated values variant"]
1374    #[inline(always)]
1375    pub const fn variant(&self) -> Hypervisor {
1376        match self.bits {
1377            false => Hypervisor::Disabled,
1378            true => Hypervisor::Enabled,
1379        }
1380    }
1381    #[doc = "disbale"]
1382    #[inline(always)]
1383    pub fn is_disabled(&self) -> bool {
1384        *self == Hypervisor::Disabled
1385    }
1386    #[doc = "enable"]
1387    #[inline(always)]
1388    pub fn is_enabled(&self) -> bool {
1389        *self == Hypervisor::Enabled
1390    }
1391}
1392#[doc = "Field `HYPERVISOR` writer - no description available"]
1393pub type HypervisorW<'a, REG> = crate::BitWriter<'a, REG, Hypervisor>;
1394impl<'a, REG> HypervisorW<'a, REG>
1395where
1396    REG: crate::Writable + crate::RegisterSpec,
1397{
1398    #[doc = "disbale"]
1399    #[inline(always)]
1400    pub fn disabled(self) -> &'a mut crate::W<REG> {
1401        self.variant(Hypervisor::Disabled)
1402    }
1403    #[doc = "enable"]
1404    #[inline(always)]
1405    pub fn enabled(self) -> &'a mut crate::W<REG> {
1406        self.variant(Hypervisor::Enabled)
1407    }
1408}
1409#[doc = "no description available\n\nValue on reset: 0"]
1410#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1411#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1412pub enum Secureviolation {
1413    #[doc = "0: disbale"]
1414    Disabled = 0,
1415    #[doc = "1: enable"]
1416    Enabled = 1,
1417}
1418impl From<Secureviolation> for bool {
1419    #[inline(always)]
1420    fn from(variant: Secureviolation) -> Self {
1421        variant as u8 != 0
1422    }
1423}
1424#[doc = "Field `SECUREVIOLATION` reader - no description available"]
1425pub type SecureviolationR = crate::BitReader<Secureviolation>;
1426impl SecureviolationR {
1427    #[doc = "Get enumerated values variant"]
1428    #[inline(always)]
1429    pub const fn variant(&self) -> Secureviolation {
1430        match self.bits {
1431            false => Secureviolation::Disabled,
1432            true => Secureviolation::Enabled,
1433        }
1434    }
1435    #[doc = "disbale"]
1436    #[inline(always)]
1437    pub fn is_disabled(&self) -> bool {
1438        *self == Secureviolation::Disabled
1439    }
1440    #[doc = "enable"]
1441    #[inline(always)]
1442    pub fn is_enabled(&self) -> bool {
1443        *self == Secureviolation::Enabled
1444    }
1445}
1446#[doc = "Field `SECUREVIOLATION` writer - no description available"]
1447pub type SecureviolationW<'a, REG> = crate::BitWriter<'a, REG, Secureviolation>;
1448impl<'a, REG> SecureviolationW<'a, REG>
1449where
1450    REG: crate::Writable + crate::RegisterSpec,
1451{
1452    #[doc = "disbale"]
1453    #[inline(always)]
1454    pub fn disabled(self) -> &'a mut crate::W<REG> {
1455        self.variant(Secureviolation::Disabled)
1456    }
1457    #[doc = "enable"]
1458    #[inline(always)]
1459    pub fn enabled(self) -> &'a mut crate::W<REG> {
1460        self.variant(Secureviolation::Enabled)
1461    }
1462}
1463#[doc = "no description available\n\nValue on reset: 0"]
1464#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1465#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1466pub enum Hwvad0 {
1467    #[doc = "0: disbale"]
1468    Disabled = 0,
1469    #[doc = "1: enable"]
1470    Enabled = 1,
1471}
1472impl From<Hwvad0> for bool {
1473    #[inline(always)]
1474    fn from(variant: Hwvad0) -> Self {
1475        variant as u8 != 0
1476    }
1477}
1478#[doc = "Field `HWVAD0` reader - no description available"]
1479pub type Hwvad0R = crate::BitReader<Hwvad0>;
1480impl Hwvad0R {
1481    #[doc = "Get enumerated values variant"]
1482    #[inline(always)]
1483    pub const fn variant(&self) -> Hwvad0 {
1484        match self.bits {
1485            false => Hwvad0::Disabled,
1486            true => Hwvad0::Enabled,
1487        }
1488    }
1489    #[doc = "disbale"]
1490    #[inline(always)]
1491    pub fn is_disabled(&self) -> bool {
1492        *self == Hwvad0::Disabled
1493    }
1494    #[doc = "enable"]
1495    #[inline(always)]
1496    pub fn is_enabled(&self) -> bool {
1497        *self == Hwvad0::Enabled
1498    }
1499}
1500#[doc = "Field `HWVAD0` writer - no description available"]
1501pub type Hwvad0W<'a, REG> = crate::BitWriter<'a, REG, Hwvad0>;
1502impl<'a, REG> Hwvad0W<'a, REG>
1503where
1504    REG: crate::Writable + crate::RegisterSpec,
1505{
1506    #[doc = "disbale"]
1507    #[inline(always)]
1508    pub fn disabled(self) -> &'a mut crate::W<REG> {
1509        self.variant(Hwvad0::Disabled)
1510    }
1511    #[doc = "enable"]
1512    #[inline(always)]
1513    pub fn enabled(self) -> &'a mut crate::W<REG> {
1514        self.variant(Hwvad0::Enabled)
1515    }
1516}
1517#[doc = "no description available\n\nValue on reset: 0"]
1518#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1519#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1520pub enum Rng {
1521    #[doc = "0: disbale"]
1522    Disabled = 0,
1523    #[doc = "1: enable"]
1524    Enabled = 1,
1525}
1526impl From<Rng> for bool {
1527    #[inline(always)]
1528    fn from(variant: Rng) -> Self {
1529        variant as u8 != 0
1530    }
1531}
1532#[doc = "Field `RNG` reader - no description available"]
1533pub type RngR = crate::BitReader<Rng>;
1534impl RngR {
1535    #[doc = "Get enumerated values variant"]
1536    #[inline(always)]
1537    pub const fn variant(&self) -> Rng {
1538        match self.bits {
1539            false => Rng::Disabled,
1540            true => Rng::Enabled,
1541        }
1542    }
1543    #[doc = "disbale"]
1544    #[inline(always)]
1545    pub fn is_disabled(&self) -> bool {
1546        *self == Rng::Disabled
1547    }
1548    #[doc = "enable"]
1549    #[inline(always)]
1550    pub fn is_enabled(&self) -> bool {
1551        *self == Rng::Enabled
1552    }
1553}
1554#[doc = "Field `RNG` writer - no description available"]
1555pub type RngW<'a, REG> = crate::BitWriter<'a, REG, Rng>;
1556impl<'a, REG> RngW<'a, REG>
1557where
1558    REG: crate::Writable + crate::RegisterSpec,
1559{
1560    #[doc = "disbale"]
1561    #[inline(always)]
1562    pub fn disabled(self) -> &'a mut crate::W<REG> {
1563        self.variant(Rng::Disabled)
1564    }
1565    #[doc = "enable"]
1566    #[inline(always)]
1567    pub fn enabled(self) -> &'a mut crate::W<REG> {
1568        self.variant(Rng::Enabled)
1569    }
1570}
1571impl R {
1572    #[doc = "Bit 0 - no description available"]
1573    #[inline(always)]
1574    pub fn wdt0(&self) -> Wdt0R {
1575        Wdt0R::new((self.bits & 1) != 0)
1576    }
1577    #[doc = "Bit 1 - no description available"]
1578    #[inline(always)]
1579    pub fn dmac0(&self) -> Dmac0R {
1580        Dmac0R::new(((self.bits >> 1) & 1) != 0)
1581    }
1582    #[doc = "Bit 2 - no description available"]
1583    #[inline(always)]
1584    pub fn nshsgpio_int0(&self) -> NshsgpioInt0R {
1585        NshsgpioInt0R::new(((self.bits >> 2) & 1) != 0)
1586    }
1587    #[doc = "Bit 3 - no description available"]
1588    #[inline(always)]
1589    pub fn nshsgpio_int1(&self) -> NshsgpioInt1R {
1590        NshsgpioInt1R::new(((self.bits >> 3) & 1) != 0)
1591    }
1592    #[doc = "Bit 4 - no description available"]
1593    #[inline(always)]
1594    pub fn gpio_int0_irq0(&self) -> GpioInt0Irq0R {
1595        GpioInt0Irq0R::new(((self.bits >> 4) & 1) != 0)
1596    }
1597    #[doc = "Bit 5 - no description available"]
1598    #[inline(always)]
1599    pub fn gpio_int0_irq1(&self) -> GpioInt0Irq1R {
1600        GpioInt0Irq1R::new(((self.bits >> 5) & 1) != 0)
1601    }
1602    #[doc = "Bit 6 - no description available"]
1603    #[inline(always)]
1604    pub fn gpio_int0_irq2(&self) -> GpioInt0Irq2R {
1605        GpioInt0Irq2R::new(((self.bits >> 6) & 1) != 0)
1606    }
1607    #[doc = "Bit 7 - no description available"]
1608    #[inline(always)]
1609    pub fn gpio_int0_irq3(&self) -> GpioInt0Irq3R {
1610        GpioInt0Irq3R::new(((self.bits >> 7) & 1) != 0)
1611    }
1612    #[doc = "Bit 8 - no description available"]
1613    #[inline(always)]
1614    pub fn utick0(&self) -> Utick0R {
1615        Utick0R::new(((self.bits >> 8) & 1) != 0)
1616    }
1617    #[doc = "Bit 9 - no description available"]
1618    #[inline(always)]
1619    pub fn mrt0(&self) -> Mrt0R {
1620        Mrt0R::new(((self.bits >> 9) & 1) != 0)
1621    }
1622    #[doc = "Bit 10 - no description available"]
1623    #[inline(always)]
1624    pub fn ct32bit0(&self) -> Ct32bit0R {
1625        Ct32bit0R::new(((self.bits >> 10) & 1) != 0)
1626    }
1627    #[doc = "Bit 11 - no description available"]
1628    #[inline(always)]
1629    pub fn ct32bit1(&self) -> Ct32bit1R {
1630        Ct32bit1R::new(((self.bits >> 11) & 1) != 0)
1631    }
1632    #[doc = "Bit 12 - no description available"]
1633    #[inline(always)]
1634    pub fn sct0(&self) -> Sct0R {
1635        Sct0R::new(((self.bits >> 12) & 1) != 0)
1636    }
1637    #[doc = "Bit 13 - no description available"]
1638    #[inline(always)]
1639    pub fn ct32bit3(&self) -> Ct32bit3R {
1640        Ct32bit3R::new(((self.bits >> 13) & 1) != 0)
1641    }
1642    #[doc = "Bit 14 - no description available"]
1643    #[inline(always)]
1644    pub fn flexcomm0(&self) -> Flexcomm0R {
1645        Flexcomm0R::new(((self.bits >> 14) & 1) != 0)
1646    }
1647    #[doc = "Bit 15 - no description available"]
1648    #[inline(always)]
1649    pub fn flexcomm1(&self) -> Flexcomm1R {
1650        Flexcomm1R::new(((self.bits >> 15) & 1) != 0)
1651    }
1652    #[doc = "Bit 16 - no description available"]
1653    #[inline(always)]
1654    pub fn flexcomm2(&self) -> Flexcomm2R {
1655        Flexcomm2R::new(((self.bits >> 16) & 1) != 0)
1656    }
1657    #[doc = "Bit 17 - no description available"]
1658    #[inline(always)]
1659    pub fn flexcomm3(&self) -> Flexcomm3R {
1660        Flexcomm3R::new(((self.bits >> 17) & 1) != 0)
1661    }
1662    #[doc = "Bit 18 - no description available"]
1663    #[inline(always)]
1664    pub fn flexcomm4(&self) -> Flexcomm4R {
1665        Flexcomm4R::new(((self.bits >> 18) & 1) != 0)
1666    }
1667    #[doc = "Bit 19 - no description available"]
1668    #[inline(always)]
1669    pub fn flexcomm5(&self) -> Flexcomm5R {
1670        Flexcomm5R::new(((self.bits >> 19) & 1) != 0)
1671    }
1672    #[doc = "Bit 20 - no description available"]
1673    #[inline(always)]
1674    pub fn flexcomm14(&self) -> Flexcomm14R {
1675        Flexcomm14R::new(((self.bits >> 20) & 1) != 0)
1676    }
1677    #[doc = "Bit 21 - no description available"]
1678    #[inline(always)]
1679    pub fn flexcomm15(&self) -> Flexcomm15R {
1680        Flexcomm15R::new(((self.bits >> 21) & 1) != 0)
1681    }
1682    #[doc = "Bit 22 - no description available"]
1683    #[inline(always)]
1684    pub fn adc0(&self) -> Adc0R {
1685        Adc0R::new(((self.bits >> 22) & 1) != 0)
1686    }
1687    #[doc = "Bit 24 - no description available"]
1688    #[inline(always)]
1689    pub fn acmp(&self) -> AcmpR {
1690        AcmpR::new(((self.bits >> 24) & 1) != 0)
1691    }
1692    #[doc = "Bit 25 - no description available"]
1693    #[inline(always)]
1694    pub fn dmic0(&self) -> Dmic0R {
1695        Dmic0R::new(((self.bits >> 25) & 1) != 0)
1696    }
1697    #[doc = "Bit 27 - no description available"]
1698    #[inline(always)]
1699    pub fn hypervisor(&self) -> HypervisorR {
1700        HypervisorR::new(((self.bits >> 27) & 1) != 0)
1701    }
1702    #[doc = "Bit 28 - no description available"]
1703    #[inline(always)]
1704    pub fn secureviolation(&self) -> SecureviolationR {
1705        SecureviolationR::new(((self.bits >> 28) & 1) != 0)
1706    }
1707    #[doc = "Bit 29 - no description available"]
1708    #[inline(always)]
1709    pub fn hwvad0(&self) -> Hwvad0R {
1710        Hwvad0R::new(((self.bits >> 29) & 1) != 0)
1711    }
1712    #[doc = "Bit 31 - no description available"]
1713    #[inline(always)]
1714    pub fn rng(&self) -> RngR {
1715        RngR::new(((self.bits >> 31) & 1) != 0)
1716    }
1717}
1718#[cfg(feature = "debug")]
1719impl core::fmt::Debug for R {
1720    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1721        f.debug_struct("STARTEN0")
1722            .field("wdt0", &self.wdt0())
1723            .field("dmac0", &self.dmac0())
1724            .field("nshsgpio_int0", &self.nshsgpio_int0())
1725            .field("nshsgpio_int1", &self.nshsgpio_int1())
1726            .field("gpio_int0_irq0", &self.gpio_int0_irq0())
1727            .field("gpio_int0_irq1", &self.gpio_int0_irq1())
1728            .field("gpio_int0_irq2", &self.gpio_int0_irq2())
1729            .field("gpio_int0_irq3", &self.gpio_int0_irq3())
1730            .field("utick0", &self.utick0())
1731            .field("mrt0", &self.mrt0())
1732            .field("ct32bit0", &self.ct32bit0())
1733            .field("ct32bit1", &self.ct32bit1())
1734            .field("sct0", &self.sct0())
1735            .field("ct32bit3", &self.ct32bit3())
1736            .field("flexcomm0", &self.flexcomm0())
1737            .field("flexcomm1", &self.flexcomm1())
1738            .field("flexcomm2", &self.flexcomm2())
1739            .field("flexcomm3", &self.flexcomm3())
1740            .field("flexcomm4", &self.flexcomm4())
1741            .field("flexcomm5", &self.flexcomm5())
1742            .field("flexcomm14", &self.flexcomm14())
1743            .field("flexcomm15", &self.flexcomm15())
1744            .field("adc0", &self.adc0())
1745            .field("acmp", &self.acmp())
1746            .field("dmic0", &self.dmic0())
1747            .field("hypervisor", &self.hypervisor())
1748            .field("secureviolation", &self.secureviolation())
1749            .field("hwvad0", &self.hwvad0())
1750            .field("rng", &self.rng())
1751            .finish()
1752    }
1753}
1754impl W {
1755    #[doc = "Bit 0 - no description available"]
1756    #[inline(always)]
1757    pub fn wdt0(&mut self) -> Wdt0W<Starten0Spec> {
1758        Wdt0W::new(self, 0)
1759    }
1760    #[doc = "Bit 1 - no description available"]
1761    #[inline(always)]
1762    pub fn dmac0(&mut self) -> Dmac0W<Starten0Spec> {
1763        Dmac0W::new(self, 1)
1764    }
1765    #[doc = "Bit 2 - no description available"]
1766    #[inline(always)]
1767    pub fn nshsgpio_int0(&mut self) -> NshsgpioInt0W<Starten0Spec> {
1768        NshsgpioInt0W::new(self, 2)
1769    }
1770    #[doc = "Bit 3 - no description available"]
1771    #[inline(always)]
1772    pub fn nshsgpio_int1(&mut self) -> NshsgpioInt1W<Starten0Spec> {
1773        NshsgpioInt1W::new(self, 3)
1774    }
1775    #[doc = "Bit 4 - no description available"]
1776    #[inline(always)]
1777    pub fn gpio_int0_irq0(&mut self) -> GpioInt0Irq0W<Starten0Spec> {
1778        GpioInt0Irq0W::new(self, 4)
1779    }
1780    #[doc = "Bit 5 - no description available"]
1781    #[inline(always)]
1782    pub fn gpio_int0_irq1(&mut self) -> GpioInt0Irq1W<Starten0Spec> {
1783        GpioInt0Irq1W::new(self, 5)
1784    }
1785    #[doc = "Bit 6 - no description available"]
1786    #[inline(always)]
1787    pub fn gpio_int0_irq2(&mut self) -> GpioInt0Irq2W<Starten0Spec> {
1788        GpioInt0Irq2W::new(self, 6)
1789    }
1790    #[doc = "Bit 7 - no description available"]
1791    #[inline(always)]
1792    pub fn gpio_int0_irq3(&mut self) -> GpioInt0Irq3W<Starten0Spec> {
1793        GpioInt0Irq3W::new(self, 7)
1794    }
1795    #[doc = "Bit 8 - no description available"]
1796    #[inline(always)]
1797    pub fn utick0(&mut self) -> Utick0W<Starten0Spec> {
1798        Utick0W::new(self, 8)
1799    }
1800    #[doc = "Bit 9 - no description available"]
1801    #[inline(always)]
1802    pub fn mrt0(&mut self) -> Mrt0W<Starten0Spec> {
1803        Mrt0W::new(self, 9)
1804    }
1805    #[doc = "Bit 10 - no description available"]
1806    #[inline(always)]
1807    pub fn ct32bit0(&mut self) -> Ct32bit0W<Starten0Spec> {
1808        Ct32bit0W::new(self, 10)
1809    }
1810    #[doc = "Bit 11 - no description available"]
1811    #[inline(always)]
1812    pub fn ct32bit1(&mut self) -> Ct32bit1W<Starten0Spec> {
1813        Ct32bit1W::new(self, 11)
1814    }
1815    #[doc = "Bit 12 - no description available"]
1816    #[inline(always)]
1817    pub fn sct0(&mut self) -> Sct0W<Starten0Spec> {
1818        Sct0W::new(self, 12)
1819    }
1820    #[doc = "Bit 13 - no description available"]
1821    #[inline(always)]
1822    pub fn ct32bit3(&mut self) -> Ct32bit3W<Starten0Spec> {
1823        Ct32bit3W::new(self, 13)
1824    }
1825    #[doc = "Bit 14 - no description available"]
1826    #[inline(always)]
1827    pub fn flexcomm0(&mut self) -> Flexcomm0W<Starten0Spec> {
1828        Flexcomm0W::new(self, 14)
1829    }
1830    #[doc = "Bit 15 - no description available"]
1831    #[inline(always)]
1832    pub fn flexcomm1(&mut self) -> Flexcomm1W<Starten0Spec> {
1833        Flexcomm1W::new(self, 15)
1834    }
1835    #[doc = "Bit 16 - no description available"]
1836    #[inline(always)]
1837    pub fn flexcomm2(&mut self) -> Flexcomm2W<Starten0Spec> {
1838        Flexcomm2W::new(self, 16)
1839    }
1840    #[doc = "Bit 17 - no description available"]
1841    #[inline(always)]
1842    pub fn flexcomm3(&mut self) -> Flexcomm3W<Starten0Spec> {
1843        Flexcomm3W::new(self, 17)
1844    }
1845    #[doc = "Bit 18 - no description available"]
1846    #[inline(always)]
1847    pub fn flexcomm4(&mut self) -> Flexcomm4W<Starten0Spec> {
1848        Flexcomm4W::new(self, 18)
1849    }
1850    #[doc = "Bit 19 - no description available"]
1851    #[inline(always)]
1852    pub fn flexcomm5(&mut self) -> Flexcomm5W<Starten0Spec> {
1853        Flexcomm5W::new(self, 19)
1854    }
1855    #[doc = "Bit 20 - no description available"]
1856    #[inline(always)]
1857    pub fn flexcomm14(&mut self) -> Flexcomm14W<Starten0Spec> {
1858        Flexcomm14W::new(self, 20)
1859    }
1860    #[doc = "Bit 21 - no description available"]
1861    #[inline(always)]
1862    pub fn flexcomm15(&mut self) -> Flexcomm15W<Starten0Spec> {
1863        Flexcomm15W::new(self, 21)
1864    }
1865    #[doc = "Bit 22 - no description available"]
1866    #[inline(always)]
1867    pub fn adc0(&mut self) -> Adc0W<Starten0Spec> {
1868        Adc0W::new(self, 22)
1869    }
1870    #[doc = "Bit 24 - no description available"]
1871    #[inline(always)]
1872    pub fn acmp(&mut self) -> AcmpW<Starten0Spec> {
1873        AcmpW::new(self, 24)
1874    }
1875    #[doc = "Bit 25 - no description available"]
1876    #[inline(always)]
1877    pub fn dmic0(&mut self) -> Dmic0W<Starten0Spec> {
1878        Dmic0W::new(self, 25)
1879    }
1880    #[doc = "Bit 27 - no description available"]
1881    #[inline(always)]
1882    pub fn hypervisor(&mut self) -> HypervisorW<Starten0Spec> {
1883        HypervisorW::new(self, 27)
1884    }
1885    #[doc = "Bit 28 - no description available"]
1886    #[inline(always)]
1887    pub fn secureviolation(&mut self) -> SecureviolationW<Starten0Spec> {
1888        SecureviolationW::new(self, 28)
1889    }
1890    #[doc = "Bit 29 - no description available"]
1891    #[inline(always)]
1892    pub fn hwvad0(&mut self) -> Hwvad0W<Starten0Spec> {
1893        Hwvad0W::new(self, 29)
1894    }
1895    #[doc = "Bit 31 - no description available"]
1896    #[inline(always)]
1897    pub fn rng(&mut self) -> RngW<Starten0Spec> {
1898        RngW::new(self, 31)
1899    }
1900}
1901#[doc = "Start enable 0\n\nYou can [`read`](crate::Reg::read) this register and get [`starten0::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`starten0::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1902pub struct Starten0Spec;
1903impl crate::RegisterSpec for Starten0Spec {
1904    type Ux = u32;
1905}
1906#[doc = "`read()` method returns [`starten0::R`](R) reader structure"]
1907impl crate::Readable for Starten0Spec {}
1908#[doc = "`write(|w| ..)` method takes [`starten0::W`](W) writer structure"]
1909impl crate::Writable for Starten0Spec {
1910    type Safety = crate::Unsafe;
1911    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1912    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1913}
1914#[doc = "`reset()` method sets STARTEN0 to value 0"]
1915impl crate::Resettable for Starten0Spec {
1916    const RESET_VALUE: u32 = 0;
1917}
mimxrt685s_pac/sysctl0/starten0.rs

mimxrt685s_pac/sysctl0/
starten0.rs
