mimxrt685s_pac/sysctl0/
starten1.rs

1#[doc = "Register `STARTEN1` reader"]
2pub type R = crate::R<Starten1Spec>;
3#[doc = "Register `STARTEN1` writer"]
4pub type W = crate::W<Starten1Spec>;
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 RtcLite0AlarmOrWakeup {
9    #[doc = "0: disbale"]
10    Disabled = 0,
11    #[doc = "1: enable"]
12    Enabled = 1,
13}
14impl From<RtcLite0AlarmOrWakeup> for bool {
15    #[inline(always)]
16    fn from(variant: RtcLite0AlarmOrWakeup) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `RTC_LITE0_ALARM_or_WAKEUP` reader - no description available"]
21pub type RtcLite0AlarmOrWakeupR = crate::BitReader<RtcLite0AlarmOrWakeup>;
22impl RtcLite0AlarmOrWakeupR {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> RtcLite0AlarmOrWakeup {
26        match self.bits {
27            false => RtcLite0AlarmOrWakeup::Disabled,
28            true => RtcLite0AlarmOrWakeup::Enabled,
29        }
30    }
31    #[doc = "disbale"]
32    #[inline(always)]
33    pub fn is_disabled(&self) -> bool {
34        *self == RtcLite0AlarmOrWakeup::Disabled
35    }
36    #[doc = "enable"]
37    #[inline(always)]
38    pub fn is_enabled(&self) -> bool {
39        *self == RtcLite0AlarmOrWakeup::Enabled
40    }
41}
42#[doc = "Field `RTC_LITE0_ALARM_or_WAKEUP` writer - no description available"]
43pub type RtcLite0AlarmOrWakeupW<'a, REG> = crate::BitWriter<'a, REG, RtcLite0AlarmOrWakeup>;
44impl<'a, REG> RtcLite0AlarmOrWakeupW<'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(RtcLite0AlarmOrWakeup::Disabled)
52    }
53    #[doc = "enable"]
54    #[inline(always)]
55    pub fn enabled(self) -> &'a mut crate::W<REG> {
56        self.variant(RtcLite0AlarmOrWakeup::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 Mu {
63    #[doc = "0: disbale"]
64    Disabled = 0,
65    #[doc = "1: enable"]
66    Enabled = 1,
67}
68impl From<Mu> for bool {
69    #[inline(always)]
70    fn from(variant: Mu) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `MU` reader - no description available"]
75pub type MuR = crate::BitReader<Mu>;
76impl MuR {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Mu {
80        match self.bits {
81            false => Mu::Disabled,
82            true => Mu::Enabled,
83        }
84    }
85    #[doc = "disbale"]
86    #[inline(always)]
87    pub fn is_disabled(&self) -> bool {
88        *self == Mu::Disabled
89    }
90    #[doc = "enable"]
91    #[inline(always)]
92    pub fn is_enabled(&self) -> bool {
93        *self == Mu::Enabled
94    }
95}
96#[doc = "Field `MU` writer - no description available"]
97pub type MuW<'a, REG> = crate::BitWriter<'a, REG, Mu>;
98impl<'a, REG> MuW<'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(Mu::Disabled)
106    }
107    #[doc = "enable"]
108    #[inline(always)]
109    pub fn enabled(self) -> &'a mut crate::W<REG> {
110        self.variant(Mu::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 GpioInt0Irq4 {
117    #[doc = "0: disbale"]
118    Disabled = 0,
119    #[doc = "1: enable"]
120    Enabled = 1,
121}
122impl From<GpioInt0Irq4> for bool {
123    #[inline(always)]
124    fn from(variant: GpioInt0Irq4) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `GPIO_INT0_IRQ4` reader - no description available"]
129pub type GpioInt0Irq4R = crate::BitReader<GpioInt0Irq4>;
130impl GpioInt0Irq4R {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> GpioInt0Irq4 {
134        match self.bits {
135            false => GpioInt0Irq4::Disabled,
136            true => GpioInt0Irq4::Enabled,
137        }
138    }
139    #[doc = "disbale"]
140    #[inline(always)]
141    pub fn is_disabled(&self) -> bool {
142        *self == GpioInt0Irq4::Disabled
143    }
144    #[doc = "enable"]
145    #[inline(always)]
146    pub fn is_enabled(&self) -> bool {
147        *self == GpioInt0Irq4::Enabled
148    }
149}
150#[doc = "Field `GPIO_INT0_IRQ4` writer - no description available"]
151pub type GpioInt0Irq4W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq4>;
152impl<'a, REG> GpioInt0Irq4W<'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(GpioInt0Irq4::Disabled)
160    }
161    #[doc = "enable"]
162    #[inline(always)]
163    pub fn enabled(self) -> &'a mut crate::W<REG> {
164        self.variant(GpioInt0Irq4::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 GpioInt0Irq5 {
171    #[doc = "0: disbale"]
172    Disabled = 0,
173    #[doc = "1: enable"]
174    Enabled = 1,
175}
176impl From<GpioInt0Irq5> for bool {
177    #[inline(always)]
178    fn from(variant: GpioInt0Irq5) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `GPIO_INT0_IRQ5` reader - no description available"]
183pub type GpioInt0Irq5R = crate::BitReader<GpioInt0Irq5>;
184impl GpioInt0Irq5R {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> GpioInt0Irq5 {
188        match self.bits {
189            false => GpioInt0Irq5::Disabled,
190            true => GpioInt0Irq5::Enabled,
191        }
192    }
193    #[doc = "disbale"]
194    #[inline(always)]
195    pub fn is_disabled(&self) -> bool {
196        *self == GpioInt0Irq5::Disabled
197    }
198    #[doc = "enable"]
199    #[inline(always)]
200    pub fn is_enabled(&self) -> bool {
201        *self == GpioInt0Irq5::Enabled
202    }
203}
204#[doc = "Field `GPIO_INT0_IRQ5` writer - no description available"]
205pub type GpioInt0Irq5W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq5>;
206impl<'a, REG> GpioInt0Irq5W<'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(GpioInt0Irq5::Disabled)
214    }
215    #[doc = "enable"]
216    #[inline(always)]
217    pub fn enabled(self) -> &'a mut crate::W<REG> {
218        self.variant(GpioInt0Irq5::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 GpioInt0Irq6 {
225    #[doc = "0: disbale"]
226    Disabled = 0,
227    #[doc = "1: enable"]
228    Enabled = 1,
229}
230impl From<GpioInt0Irq6> for bool {
231    #[inline(always)]
232    fn from(variant: GpioInt0Irq6) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `GPIO_INT0_IRQ6` reader - no description available"]
237pub type GpioInt0Irq6R = crate::BitReader<GpioInt0Irq6>;
238impl GpioInt0Irq6R {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> GpioInt0Irq6 {
242        match self.bits {
243            false => GpioInt0Irq6::Disabled,
244            true => GpioInt0Irq6::Enabled,
245        }
246    }
247    #[doc = "disbale"]
248    #[inline(always)]
249    pub fn is_disabled(&self) -> bool {
250        *self == GpioInt0Irq6::Disabled
251    }
252    #[doc = "enable"]
253    #[inline(always)]
254    pub fn is_enabled(&self) -> bool {
255        *self == GpioInt0Irq6::Enabled
256    }
257}
258#[doc = "Field `GPIO_INT0_IRQ6` writer - no description available"]
259pub type GpioInt0Irq6W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq6>;
260impl<'a, REG> GpioInt0Irq6W<'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(GpioInt0Irq6::Disabled)
268    }
269    #[doc = "enable"]
270    #[inline(always)]
271    pub fn enabled(self) -> &'a mut crate::W<REG> {
272        self.variant(GpioInt0Irq6::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 GpioInt0Irq7 {
279    #[doc = "0: disbale"]
280    Disabled = 0,
281    #[doc = "1: enable"]
282    Enabled = 1,
283}
284impl From<GpioInt0Irq7> for bool {
285    #[inline(always)]
286    fn from(variant: GpioInt0Irq7) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `GPIO_INT0_IRQ7` reader - no description available"]
291pub type GpioInt0Irq7R = crate::BitReader<GpioInt0Irq7>;
292impl GpioInt0Irq7R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> GpioInt0Irq7 {
296        match self.bits {
297            false => GpioInt0Irq7::Disabled,
298            true => GpioInt0Irq7::Enabled,
299        }
300    }
301    #[doc = "disbale"]
302    #[inline(always)]
303    pub fn is_disabled(&self) -> bool {
304        *self == GpioInt0Irq7::Disabled
305    }
306    #[doc = "enable"]
307    #[inline(always)]
308    pub fn is_enabled(&self) -> bool {
309        *self == GpioInt0Irq7::Enabled
310    }
311}
312#[doc = "Field `GPIO_INT0_IRQ7` writer - no description available"]
313pub type GpioInt0Irq7W<'a, REG> = crate::BitWriter<'a, REG, GpioInt0Irq7>;
314impl<'a, REG> GpioInt0Irq7W<'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(GpioInt0Irq7::Disabled)
322    }
323    #[doc = "enable"]
324    #[inline(always)]
325    pub fn enabled(self) -> &'a mut crate::W<REG> {
326        self.variant(GpioInt0Irq7::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 Ct32bit2 {
333    #[doc = "0: disbale"]
334    Disabled = 0,
335    #[doc = "1: enable"]
336    Enabled = 1,
337}
338impl From<Ct32bit2> for bool {
339    #[inline(always)]
340    fn from(variant: Ct32bit2) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `CT32BIT2` reader - no description available"]
345pub type Ct32bit2R = crate::BitReader<Ct32bit2>;
346impl Ct32bit2R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> Ct32bit2 {
350        match self.bits {
351            false => Ct32bit2::Disabled,
352            true => Ct32bit2::Enabled,
353        }
354    }
355    #[doc = "disbale"]
356    #[inline(always)]
357    pub fn is_disabled(&self) -> bool {
358        *self == Ct32bit2::Disabled
359    }
360    #[doc = "enable"]
361    #[inline(always)]
362    pub fn is_enabled(&self) -> bool {
363        *self == Ct32bit2::Enabled
364    }
365}
366#[doc = "Field `CT32BIT2` writer - no description available"]
367pub type Ct32bit2W<'a, REG> = crate::BitWriter<'a, REG, Ct32bit2>;
368impl<'a, REG> Ct32bit2W<'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(Ct32bit2::Disabled)
376    }
377    #[doc = "enable"]
378    #[inline(always)]
379    pub fn enabled(self) -> &'a mut crate::W<REG> {
380        self.variant(Ct32bit2::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 Ct32bit4 {
387    #[doc = "0: disbale"]
388    Disabled = 0,
389    #[doc = "1: enable"]
390    Enabled = 1,
391}
392impl From<Ct32bit4> for bool {
393    #[inline(always)]
394    fn from(variant: Ct32bit4) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `CT32BIT4` reader - no description available"]
399pub type Ct32bit4R = crate::BitReader<Ct32bit4>;
400impl Ct32bit4R {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> Ct32bit4 {
404        match self.bits {
405            false => Ct32bit4::Disabled,
406            true => Ct32bit4::Enabled,
407        }
408    }
409    #[doc = "disbale"]
410    #[inline(always)]
411    pub fn is_disabled(&self) -> bool {
412        *self == Ct32bit4::Disabled
413    }
414    #[doc = "enable"]
415    #[inline(always)]
416    pub fn is_enabled(&self) -> bool {
417        *self == Ct32bit4::Enabled
418    }
419}
420#[doc = "Field `CT32BIT4` writer - no description available"]
421pub type Ct32bit4W<'a, REG> = crate::BitWriter<'a, REG, Ct32bit4>;
422impl<'a, REG> Ct32bit4W<'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(Ct32bit4::Disabled)
430    }
431    #[doc = "enable"]
432    #[inline(always)]
433    pub fn enabled(self) -> &'a mut crate::W<REG> {
434        self.variant(Ct32bit4::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 OsEventTimerWu {
441    #[doc = "0: disbale"]
442    Disabled = 0,
443    #[doc = "1: enable"]
444    Enabled = 1,
445}
446impl From<OsEventTimerWu> for bool {
447    #[inline(always)]
448    fn from(variant: OsEventTimerWu) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `OS_EVENT_TIMER_WU` reader - no description available"]
453pub type OsEventTimerWuR = crate::BitReader<OsEventTimerWu>;
454impl OsEventTimerWuR {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> OsEventTimerWu {
458        match self.bits {
459            false => OsEventTimerWu::Disabled,
460            true => OsEventTimerWu::Enabled,
461        }
462    }
463    #[doc = "disbale"]
464    #[inline(always)]
465    pub fn is_disabled(&self) -> bool {
466        *self == OsEventTimerWu::Disabled
467    }
468    #[doc = "enable"]
469    #[inline(always)]
470    pub fn is_enabled(&self) -> bool {
471        *self == OsEventTimerWu::Enabled
472    }
473}
474#[doc = "Field `OS_EVENT_TIMER_WU` writer - no description available"]
475pub type OsEventTimerWuW<'a, REG> = crate::BitWriter<'a, REG, OsEventTimerWu>;
476impl<'a, REG> OsEventTimerWuW<'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(OsEventTimerWu::Disabled)
484    }
485    #[doc = "enable"]
486    #[inline(always)]
487    pub fn enabled(self) -> &'a mut crate::W<REG> {
488        self.variant(OsEventTimerWu::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 Flexspi {
495    #[doc = "0: disbale"]
496    Disabled = 0,
497    #[doc = "1: enable"]
498    Enabled = 1,
499}
500impl From<Flexspi> for bool {
501    #[inline(always)]
502    fn from(variant: Flexspi) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `FLEXSPI` reader - no description available"]
507pub type FlexspiR = crate::BitReader<Flexspi>;
508impl FlexspiR {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Flexspi {
512        match self.bits {
513            false => Flexspi::Disabled,
514            true => Flexspi::Enabled,
515        }
516    }
517    #[doc = "disbale"]
518    #[inline(always)]
519    pub fn is_disabled(&self) -> bool {
520        *self == Flexspi::Disabled
521    }
522    #[doc = "enable"]
523    #[inline(always)]
524    pub fn is_enabled(&self) -> bool {
525        *self == Flexspi::Enabled
526    }
527}
528#[doc = "Field `FLEXSPI` writer - no description available"]
529pub type FlexspiW<'a, REG> = crate::BitWriter<'a, REG, Flexspi>;
530impl<'a, REG> FlexspiW<'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(Flexspi::Disabled)
538    }
539    #[doc = "enable"]
540    #[inline(always)]
541    pub fn enabled(self) -> &'a mut crate::W<REG> {
542        self.variant(Flexspi::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 Flexcomm6 {
549    #[doc = "0: disbale"]
550    Disabled = 0,
551    #[doc = "1: enable"]
552    Enabled = 1,
553}
554impl From<Flexcomm6> for bool {
555    #[inline(always)]
556    fn from(variant: Flexcomm6) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `FLEXCOMM6` reader - no description available"]
561pub type Flexcomm6R = crate::BitReader<Flexcomm6>;
562impl Flexcomm6R {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Flexcomm6 {
566        match self.bits {
567            false => Flexcomm6::Disabled,
568            true => Flexcomm6::Enabled,
569        }
570    }
571    #[doc = "disbale"]
572    #[inline(always)]
573    pub fn is_disabled(&self) -> bool {
574        *self == Flexcomm6::Disabled
575    }
576    #[doc = "enable"]
577    #[inline(always)]
578    pub fn is_enabled(&self) -> bool {
579        *self == Flexcomm6::Enabled
580    }
581}
582#[doc = "Field `FLEXCOMM6` writer - no description available"]
583pub type Flexcomm6W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm6>;
584impl<'a, REG> Flexcomm6W<'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(Flexcomm6::Disabled)
592    }
593    #[doc = "enable"]
594    #[inline(always)]
595    pub fn enabled(self) -> &'a mut crate::W<REG> {
596        self.variant(Flexcomm6::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 Flexcomm7 {
603    #[doc = "0: disbale"]
604    Disabled = 0,
605    #[doc = "1: enable"]
606    Enabled = 1,
607}
608impl From<Flexcomm7> for bool {
609    #[inline(always)]
610    fn from(variant: Flexcomm7) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `FLEXCOMM7` reader - no description available"]
615pub type Flexcomm7R = crate::BitReader<Flexcomm7>;
616impl Flexcomm7R {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Flexcomm7 {
620        match self.bits {
621            false => Flexcomm7::Disabled,
622            true => Flexcomm7::Enabled,
623        }
624    }
625    #[doc = "disbale"]
626    #[inline(always)]
627    pub fn is_disabled(&self) -> bool {
628        *self == Flexcomm7::Disabled
629    }
630    #[doc = "enable"]
631    #[inline(always)]
632    pub fn is_enabled(&self) -> bool {
633        *self == Flexcomm7::Enabled
634    }
635}
636#[doc = "Field `FLEXCOMM7` writer - no description available"]
637pub type Flexcomm7W<'a, REG> = crate::BitWriter<'a, REG, Flexcomm7>;
638impl<'a, REG> Flexcomm7W<'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(Flexcomm7::Disabled)
646    }
647    #[doc = "enable"]
648    #[inline(always)]
649    pub fn enabled(self) -> &'a mut crate::W<REG> {
650        self.variant(Flexcomm7::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 Sdio0 {
657    #[doc = "0: disbale"]
658    Disabled = 0,
659    #[doc = "1: enable"]
660    Enabled = 1,
661}
662impl From<Sdio0> for bool {
663    #[inline(always)]
664    fn from(variant: Sdio0) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `SDIO0` reader - no description available"]
669pub type Sdio0R = crate::BitReader<Sdio0>;
670impl Sdio0R {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Sdio0 {
674        match self.bits {
675            false => Sdio0::Disabled,
676            true => Sdio0::Enabled,
677        }
678    }
679    #[doc = "disbale"]
680    #[inline(always)]
681    pub fn is_disabled(&self) -> bool {
682        *self == Sdio0::Disabled
683    }
684    #[doc = "enable"]
685    #[inline(always)]
686    pub fn is_enabled(&self) -> bool {
687        *self == Sdio0::Enabled
688    }
689}
690#[doc = "Field `SDIO0` writer - no description available"]
691pub type Sdio0W<'a, REG> = crate::BitWriter<'a, REG, Sdio0>;
692impl<'a, REG> Sdio0W<'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(Sdio0::Disabled)
700    }
701    #[doc = "enable"]
702    #[inline(always)]
703    pub fn enabled(self) -> &'a mut crate::W<REG> {
704        self.variant(Sdio0::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 Sdio1 {
711    #[doc = "0: disbale"]
712    Disabled = 0,
713    #[doc = "1: enable"]
714    Enabled = 1,
715}
716impl From<Sdio1> for bool {
717    #[inline(always)]
718    fn from(variant: Sdio1) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `SDIO1` reader - no description available"]
723pub type Sdio1R = crate::BitReader<Sdio1>;
724impl Sdio1R {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Sdio1 {
728        match self.bits {
729            false => Sdio1::Disabled,
730            true => Sdio1::Enabled,
731        }
732    }
733    #[doc = "disbale"]
734    #[inline(always)]
735    pub fn is_disabled(&self) -> bool {
736        *self == Sdio1::Disabled
737    }
738    #[doc = "enable"]
739    #[inline(always)]
740    pub fn is_enabled(&self) -> bool {
741        *self == Sdio1::Enabled
742    }
743}
744#[doc = "Field `SDIO1` writer - no description available"]
745pub type Sdio1W<'a, REG> = crate::BitWriter<'a, REG, Sdio1>;
746impl<'a, REG> Sdio1W<'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(Sdio1::Disabled)
754    }
755    #[doc = "enable"]
756    #[inline(always)]
757    pub fn enabled(self) -> &'a mut crate::W<REG> {
758        self.variant(Sdio1::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 ShsgpioInt0 {
765    #[doc = "0: disbale"]
766    Disabled = 0,
767    #[doc = "1: enable"]
768    Enabled = 1,
769}
770impl From<ShsgpioInt0> for bool {
771    #[inline(always)]
772    fn from(variant: ShsgpioInt0) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `SHSGPIO_INT0` reader - no description available"]
777pub type ShsgpioInt0R = crate::BitReader<ShsgpioInt0>;
778impl ShsgpioInt0R {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> ShsgpioInt0 {
782        match self.bits {
783            false => ShsgpioInt0::Disabled,
784            true => ShsgpioInt0::Enabled,
785        }
786    }
787    #[doc = "disbale"]
788    #[inline(always)]
789    pub fn is_disabled(&self) -> bool {
790        *self == ShsgpioInt0::Disabled
791    }
792    #[doc = "enable"]
793    #[inline(always)]
794    pub fn is_enabled(&self) -> bool {
795        *self == ShsgpioInt0::Enabled
796    }
797}
798#[doc = "Field `SHSGPIO_INT0` writer - no description available"]
799pub type ShsgpioInt0W<'a, REG> = crate::BitWriter<'a, REG, ShsgpioInt0>;
800impl<'a, REG> ShsgpioInt0W<'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(ShsgpioInt0::Disabled)
808    }
809    #[doc = "enable"]
810    #[inline(always)]
811    pub fn enabled(self) -> &'a mut crate::W<REG> {
812        self.variant(ShsgpioInt0::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 ShsgpioInt1 {
819    #[doc = "0: disbale"]
820    Disabled = 0,
821    #[doc = "1: enable"]
822    Enabled = 1,
823}
824impl From<ShsgpioInt1> for bool {
825    #[inline(always)]
826    fn from(variant: ShsgpioInt1) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `SHSGPIO_INT1` reader - no description available"]
831pub type ShsgpioInt1R = crate::BitReader<ShsgpioInt1>;
832impl ShsgpioInt1R {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> ShsgpioInt1 {
836        match self.bits {
837            false => ShsgpioInt1::Disabled,
838            true => ShsgpioInt1::Enabled,
839        }
840    }
841    #[doc = "disbale"]
842    #[inline(always)]
843    pub fn is_disabled(&self) -> bool {
844        *self == ShsgpioInt1::Disabled
845    }
846    #[doc = "enable"]
847    #[inline(always)]
848    pub fn is_enabled(&self) -> bool {
849        *self == ShsgpioInt1::Enabled
850    }
851}
852#[doc = "Field `SHSGPIO_INT1` writer - no description available"]
853pub type ShsgpioInt1W<'a, REG> = crate::BitWriter<'a, REG, ShsgpioInt1>;
854impl<'a, REG> ShsgpioInt1W<'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(ShsgpioInt1::Disabled)
862    }
863    #[doc = "enable"]
864    #[inline(always)]
865    pub fn enabled(self) -> &'a mut crate::W<REG> {
866        self.variant(ShsgpioInt1::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 I3c0 {
873    #[doc = "0: disbale"]
874    Disabled = 0,
875    #[doc = "1: enable"]
876    Enabled = 1,
877}
878impl From<I3c0> for bool {
879    #[inline(always)]
880    fn from(variant: I3c0) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `I3C0` reader - no description available"]
885pub type I3c0R = crate::BitReader<I3c0>;
886impl I3c0R {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> I3c0 {
890        match self.bits {
891            false => I3c0::Disabled,
892            true => I3c0::Enabled,
893        }
894    }
895    #[doc = "disbale"]
896    #[inline(always)]
897    pub fn is_disabled(&self) -> bool {
898        *self == I3c0::Disabled
899    }
900    #[doc = "enable"]
901    #[inline(always)]
902    pub fn is_enabled(&self) -> bool {
903        *self == I3c0::Enabled
904    }
905}
906#[doc = "Field `I3C0` writer - no description available"]
907pub type I3c0W<'a, REG> = crate::BitWriter<'a, REG, I3c0>;
908impl<'a, REG> I3c0W<'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(I3c0::Disabled)
916    }
917    #[doc = "enable"]
918    #[inline(always)]
919    pub fn enabled(self) -> &'a mut crate::W<REG> {
920        self.variant(I3c0::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 UsbIrq {
927    #[doc = "0: disbale"]
928    Disabled = 0,
929    #[doc = "1: enable"]
930    Enabled = 1,
931}
932impl From<UsbIrq> for bool {
933    #[inline(always)]
934    fn from(variant: UsbIrq) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `USB_IRQ` reader - no description available"]
939pub type UsbIrqR = crate::BitReader<UsbIrq>;
940impl UsbIrqR {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> UsbIrq {
944        match self.bits {
945            false => UsbIrq::Disabled,
946            true => UsbIrq::Enabled,
947        }
948    }
949    #[doc = "disbale"]
950    #[inline(always)]
951    pub fn is_disabled(&self) -> bool {
952        *self == UsbIrq::Disabled
953    }
954    #[doc = "enable"]
955    #[inline(always)]
956    pub fn is_enabled(&self) -> bool {
957        *self == UsbIrq::Enabled
958    }
959}
960#[doc = "Field `USB_IRQ` writer - no description available"]
961pub type UsbIrqW<'a, REG> = crate::BitWriter<'a, REG, UsbIrq>;
962impl<'a, REG> UsbIrqW<'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(UsbIrq::Disabled)
970    }
971    #[doc = "enable"]
972    #[inline(always)]
973    pub fn enabled(self) -> &'a mut crate::W<REG> {
974        self.variant(UsbIrq::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 UsbNeedclk {
981    #[doc = "0: disbale"]
982    Disabled = 0,
983    #[doc = "1: enable"]
984    Enabled = 1,
985}
986impl From<UsbNeedclk> for bool {
987    #[inline(always)]
988    fn from(variant: UsbNeedclk) -> Self {
989        variant as u8 != 0
990    }
991}
992#[doc = "Field `USB_NEEDCLK` reader - no description available"]
993pub type UsbNeedclkR = crate::BitReader<UsbNeedclk>;
994impl UsbNeedclkR {
995    #[doc = "Get enumerated values variant"]
996    #[inline(always)]
997    pub const fn variant(&self) -> UsbNeedclk {
998        match self.bits {
999            false => UsbNeedclk::Disabled,
1000            true => UsbNeedclk::Enabled,
1001        }
1002    }
1003    #[doc = "disbale"]
1004    #[inline(always)]
1005    pub fn is_disabled(&self) -> bool {
1006        *self == UsbNeedclk::Disabled
1007    }
1008    #[doc = "enable"]
1009    #[inline(always)]
1010    pub fn is_enabled(&self) -> bool {
1011        *self == UsbNeedclk::Enabled
1012    }
1013}
1014#[doc = "Field `USB_NEEDCLK` writer - no description available"]
1015pub type UsbNeedclkW<'a, REG> = crate::BitWriter<'a, REG, UsbNeedclk>;
1016impl<'a, REG> UsbNeedclkW<'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(UsbNeedclk::Disabled)
1024    }
1025    #[doc = "enable"]
1026    #[inline(always)]
1027    pub fn enabled(self) -> &'a mut crate::W<REG> {
1028        self.variant(UsbNeedclk::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 Dmac1 {
1035    #[doc = "0: disbale"]
1036    Disabled = 0,
1037    #[doc = "1: enable"]
1038    Enabled = 1,
1039}
1040impl From<Dmac1> for bool {
1041    #[inline(always)]
1042    fn from(variant: Dmac1) -> Self {
1043        variant as u8 != 0
1044    }
1045}
1046#[doc = "Field `DMAC1` reader - no description available"]
1047pub type Dmac1R = crate::BitReader<Dmac1>;
1048impl Dmac1R {
1049    #[doc = "Get enumerated values variant"]
1050    #[inline(always)]
1051    pub const fn variant(&self) -> Dmac1 {
1052        match self.bits {
1053            false => Dmac1::Disabled,
1054            true => Dmac1::Enabled,
1055        }
1056    }
1057    #[doc = "disbale"]
1058    #[inline(always)]
1059    pub fn is_disabled(&self) -> bool {
1060        *self == Dmac1::Disabled
1061    }
1062    #[doc = "enable"]
1063    #[inline(always)]
1064    pub fn is_enabled(&self) -> bool {
1065        *self == Dmac1::Enabled
1066    }
1067}
1068#[doc = "Field `DMAC1` writer - no description available"]
1069pub type Dmac1W<'a, REG> = crate::BitWriter<'a, REG, Dmac1>;
1070impl<'a, REG> Dmac1W<'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(Dmac1::Disabled)
1078    }
1079    #[doc = "enable"]
1080    #[inline(always)]
1081    pub fn enabled(self) -> &'a mut crate::W<REG> {
1082        self.variant(Dmac1::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 Puf {
1089    #[doc = "0: disbale"]
1090    Disabled = 0,
1091    #[doc = "1: enable"]
1092    Enabled = 1,
1093}
1094impl From<Puf> for bool {
1095    #[inline(always)]
1096    fn from(variant: Puf) -> Self {
1097        variant as u8 != 0
1098    }
1099}
1100#[doc = "Field `PUF` reader - no description available"]
1101pub type PufR = crate::BitReader<Puf>;
1102impl PufR {
1103    #[doc = "Get enumerated values variant"]
1104    #[inline(always)]
1105    pub const fn variant(&self) -> Puf {
1106        match self.bits {
1107            false => Puf::Disabled,
1108            true => Puf::Enabled,
1109        }
1110    }
1111    #[doc = "disbale"]
1112    #[inline(always)]
1113    pub fn is_disabled(&self) -> bool {
1114        *self == Puf::Disabled
1115    }
1116    #[doc = "enable"]
1117    #[inline(always)]
1118    pub fn is_enabled(&self) -> bool {
1119        *self == Puf::Enabled
1120    }
1121}
1122#[doc = "Field `PUF` writer - no description available"]
1123pub type PufW<'a, REG> = crate::BitWriter<'a, REG, Puf>;
1124impl<'a, REG> PufW<'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(Puf::Disabled)
1132    }
1133    #[doc = "enable"]
1134    #[inline(always)]
1135    pub fn enabled(self) -> &'a mut crate::W<REG> {
1136        self.variant(Puf::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 Powerquad {
1143    #[doc = "0: disbale"]
1144    Disabled = 0,
1145    #[doc = "1: enable"]
1146    Enabled = 1,
1147}
1148impl From<Powerquad> for bool {
1149    #[inline(always)]
1150    fn from(variant: Powerquad) -> Self {
1151        variant as u8 != 0
1152    }
1153}
1154#[doc = "Field `POWERQUAD` reader - no description available"]
1155pub type PowerquadR = crate::BitReader<Powerquad>;
1156impl PowerquadR {
1157    #[doc = "Get enumerated values variant"]
1158    #[inline(always)]
1159    pub const fn variant(&self) -> Powerquad {
1160        match self.bits {
1161            false => Powerquad::Disabled,
1162            true => Powerquad::Enabled,
1163        }
1164    }
1165    #[doc = "disbale"]
1166    #[inline(always)]
1167    pub fn is_disabled(&self) -> bool {
1168        *self == Powerquad::Disabled
1169    }
1170    #[doc = "enable"]
1171    #[inline(always)]
1172    pub fn is_enabled(&self) -> bool {
1173        *self == Powerquad::Enabled
1174    }
1175}
1176#[doc = "Field `POWERQUAD` writer - no description available"]
1177pub type PowerquadW<'a, REG> = crate::BitWriter<'a, REG, Powerquad>;
1178impl<'a, REG> PowerquadW<'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(Powerquad::Disabled)
1186    }
1187    #[doc = "enable"]
1188    #[inline(always)]
1189    pub fn enabled(self) -> &'a mut crate::W<REG> {
1190        self.variant(Powerquad::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 Casper {
1197    #[doc = "0: disbale"]
1198    Disabled = 0,
1199    #[doc = "1: enable"]
1200    Enabled = 1,
1201}
1202impl From<Casper> for bool {
1203    #[inline(always)]
1204    fn from(variant: Casper) -> Self {
1205        variant as u8 != 0
1206    }
1207}
1208#[doc = "Field `CASPER` reader - no description available"]
1209pub type CasperR = crate::BitReader<Casper>;
1210impl CasperR {
1211    #[doc = "Get enumerated values variant"]
1212    #[inline(always)]
1213    pub const fn variant(&self) -> Casper {
1214        match self.bits {
1215            false => Casper::Disabled,
1216            true => Casper::Enabled,
1217        }
1218    }
1219    #[doc = "disbale"]
1220    #[inline(always)]
1221    pub fn is_disabled(&self) -> bool {
1222        *self == Casper::Disabled
1223    }
1224    #[doc = "enable"]
1225    #[inline(always)]
1226    pub fn is_enabled(&self) -> bool {
1227        *self == Casper::Enabled
1228    }
1229}
1230#[doc = "Field `CASPER` writer - no description available"]
1231pub type CasperW<'a, REG> = crate::BitWriter<'a, REG, Casper>;
1232impl<'a, REG> CasperW<'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(Casper::Disabled)
1240    }
1241    #[doc = "enable"]
1242    #[inline(always)]
1243    pub fn enabled(self) -> &'a mut crate::W<REG> {
1244        self.variant(Casper::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 Pmic {
1251    #[doc = "0: disbale"]
1252    Disabled = 0,
1253    #[doc = "1: enable"]
1254    Enabled = 1,
1255}
1256impl From<Pmic> for bool {
1257    #[inline(always)]
1258    fn from(variant: Pmic) -> Self {
1259        variant as u8 != 0
1260    }
1261}
1262#[doc = "Field `PMIC` reader - no description available"]
1263pub type PmicR = crate::BitReader<Pmic>;
1264impl PmicR {
1265    #[doc = "Get enumerated values variant"]
1266    #[inline(always)]
1267    pub const fn variant(&self) -> Pmic {
1268        match self.bits {
1269            false => Pmic::Disabled,
1270            true => Pmic::Enabled,
1271        }
1272    }
1273    #[doc = "disbale"]
1274    #[inline(always)]
1275    pub fn is_disabled(&self) -> bool {
1276        *self == Pmic::Disabled
1277    }
1278    #[doc = "enable"]
1279    #[inline(always)]
1280    pub fn is_enabled(&self) -> bool {
1281        *self == Pmic::Enabled
1282    }
1283}
1284#[doc = "Field `PMIC` writer - no description available"]
1285pub type PmicW<'a, REG> = crate::BitWriter<'a, REG, Pmic>;
1286impl<'a, REG> PmicW<'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(Pmic::Disabled)
1294    }
1295    #[doc = "enable"]
1296    #[inline(always)]
1297    pub fn enabled(self) -> &'a mut crate::W<REG> {
1298        self.variant(Pmic::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 Sha {
1305    #[doc = "0: disbale"]
1306    Disabled = 0,
1307    #[doc = "1: enable"]
1308    Enabled = 1,
1309}
1310impl From<Sha> for bool {
1311    #[inline(always)]
1312    fn from(variant: Sha) -> Self {
1313        variant as u8 != 0
1314    }
1315}
1316#[doc = "Field `SHA` reader - no description available"]
1317pub type ShaR = crate::BitReader<Sha>;
1318impl ShaR {
1319    #[doc = "Get enumerated values variant"]
1320    #[inline(always)]
1321    pub const fn variant(&self) -> Sha {
1322        match self.bits {
1323            false => Sha::Disabled,
1324            true => Sha::Enabled,
1325        }
1326    }
1327    #[doc = "disbale"]
1328    #[inline(always)]
1329    pub fn is_disabled(&self) -> bool {
1330        *self == Sha::Disabled
1331    }
1332    #[doc = "enable"]
1333    #[inline(always)]
1334    pub fn is_enabled(&self) -> bool {
1335        *self == Sha::Enabled
1336    }
1337}
1338#[doc = "Field `SHA` writer - no description available"]
1339pub type ShaW<'a, REG> = crate::BitWriter<'a, REG, Sha>;
1340impl<'a, REG> ShaW<'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(Sha::Disabled)
1348    }
1349    #[doc = "enable"]
1350    #[inline(always)]
1351    pub fn enabled(self) -> &'a mut crate::W<REG> {
1352        self.variant(Sha::Enabled)
1353    }
1354}
1355impl R {
1356    #[doc = "Bit 0 - no description available"]
1357    #[inline(always)]
1358    pub fn rtc_lite0_alarm_or_wakeup(&self) -> RtcLite0AlarmOrWakeupR {
1359        RtcLite0AlarmOrWakeupR::new((self.bits & 1) != 0)
1360    }
1361    #[doc = "Bit 2 - no description available"]
1362    #[inline(always)]
1363    pub fn mu(&self) -> MuR {
1364        MuR::new(((self.bits >> 2) & 1) != 0)
1365    }
1366    #[doc = "Bit 3 - no description available"]
1367    #[inline(always)]
1368    pub fn gpio_int0_irq4(&self) -> GpioInt0Irq4R {
1369        GpioInt0Irq4R::new(((self.bits >> 3) & 1) != 0)
1370    }
1371    #[doc = "Bit 4 - no description available"]
1372    #[inline(always)]
1373    pub fn gpio_int0_irq5(&self) -> GpioInt0Irq5R {
1374        GpioInt0Irq5R::new(((self.bits >> 4) & 1) != 0)
1375    }
1376    #[doc = "Bit 5 - no description available"]
1377    #[inline(always)]
1378    pub fn gpio_int0_irq6(&self) -> GpioInt0Irq6R {
1379        GpioInt0Irq6R::new(((self.bits >> 5) & 1) != 0)
1380    }
1381    #[doc = "Bit 6 - no description available"]
1382    #[inline(always)]
1383    pub fn gpio_int0_irq7(&self) -> GpioInt0Irq7R {
1384        GpioInt0Irq7R::new(((self.bits >> 6) & 1) != 0)
1385    }
1386    #[doc = "Bit 7 - no description available"]
1387    #[inline(always)]
1388    pub fn ct32bit2(&self) -> Ct32bit2R {
1389        Ct32bit2R::new(((self.bits >> 7) & 1) != 0)
1390    }
1391    #[doc = "Bit 8 - no description available"]
1392    #[inline(always)]
1393    pub fn ct32bit4(&self) -> Ct32bit4R {
1394        Ct32bit4R::new(((self.bits >> 8) & 1) != 0)
1395    }
1396    #[doc = "Bit 9 - no description available"]
1397    #[inline(always)]
1398    pub fn os_event_timer_wu(&self) -> OsEventTimerWuR {
1399        OsEventTimerWuR::new(((self.bits >> 9) & 1) != 0)
1400    }
1401    #[doc = "Bit 10 - no description available"]
1402    #[inline(always)]
1403    pub fn flexspi(&self) -> FlexspiR {
1404        FlexspiR::new(((self.bits >> 10) & 1) != 0)
1405    }
1406    #[doc = "Bit 11 - no description available"]
1407    #[inline(always)]
1408    pub fn flexcomm6(&self) -> Flexcomm6R {
1409        Flexcomm6R::new(((self.bits >> 11) & 1) != 0)
1410    }
1411    #[doc = "Bit 12 - no description available"]
1412    #[inline(always)]
1413    pub fn flexcomm7(&self) -> Flexcomm7R {
1414        Flexcomm7R::new(((self.bits >> 12) & 1) != 0)
1415    }
1416    #[doc = "Bit 13 - no description available"]
1417    #[inline(always)]
1418    pub fn sdio0(&self) -> Sdio0R {
1419        Sdio0R::new(((self.bits >> 13) & 1) != 0)
1420    }
1421    #[doc = "Bit 14 - no description available"]
1422    #[inline(always)]
1423    pub fn sdio1(&self) -> Sdio1R {
1424        Sdio1R::new(((self.bits >> 14) & 1) != 0)
1425    }
1426    #[doc = "Bit 15 - no description available"]
1427    #[inline(always)]
1428    pub fn shsgpio_int0(&self) -> ShsgpioInt0R {
1429        ShsgpioInt0R::new(((self.bits >> 15) & 1) != 0)
1430    }
1431    #[doc = "Bit 16 - no description available"]
1432    #[inline(always)]
1433    pub fn shsgpio_int1(&self) -> ShsgpioInt1R {
1434        ShsgpioInt1R::new(((self.bits >> 16) & 1) != 0)
1435    }
1436    #[doc = "Bit 17 - no description available"]
1437    #[inline(always)]
1438    pub fn i3c0(&self) -> I3c0R {
1439        I3c0R::new(((self.bits >> 17) & 1) != 0)
1440    }
1441    #[doc = "Bit 18 - no description available"]
1442    #[inline(always)]
1443    pub fn usb_irq(&self) -> UsbIrqR {
1444        UsbIrqR::new(((self.bits >> 18) & 1) != 0)
1445    }
1446    #[doc = "Bit 19 - no description available"]
1447    #[inline(always)]
1448    pub fn usb_needclk(&self) -> UsbNeedclkR {
1449        UsbNeedclkR::new(((self.bits >> 19) & 1) != 0)
1450    }
1451    #[doc = "Bit 22 - no description available"]
1452    #[inline(always)]
1453    pub fn dmac1(&self) -> Dmac1R {
1454        Dmac1R::new(((self.bits >> 22) & 1) != 0)
1455    }
1456    #[doc = "Bit 23 - no description available"]
1457    #[inline(always)]
1458    pub fn puf(&self) -> PufR {
1459        PufR::new(((self.bits >> 23) & 1) != 0)
1460    }
1461    #[doc = "Bit 24 - no description available"]
1462    #[inline(always)]
1463    pub fn powerquad(&self) -> PowerquadR {
1464        PowerquadR::new(((self.bits >> 24) & 1) != 0)
1465    }
1466    #[doc = "Bit 25 - no description available"]
1467    #[inline(always)]
1468    pub fn casper(&self) -> CasperR {
1469        CasperR::new(((self.bits >> 25) & 1) != 0)
1470    }
1471    #[doc = "Bit 26 - no description available"]
1472    #[inline(always)]
1473    pub fn pmic(&self) -> PmicR {
1474        PmicR::new(((self.bits >> 26) & 1) != 0)
1475    }
1476    #[doc = "Bit 27 - no description available"]
1477    #[inline(always)]
1478    pub fn sha(&self) -> ShaR {
1479        ShaR::new(((self.bits >> 27) & 1) != 0)
1480    }
1481}
1482#[cfg(feature = "debug")]
1483impl core::fmt::Debug for R {
1484    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1485        f.debug_struct("STARTEN1")
1486            .field(
1487                "rtc_lite0_alarm_or_wakeup",
1488                &self.rtc_lite0_alarm_or_wakeup(),
1489            )
1490            .field("mu", &self.mu())
1491            .field("gpio_int0_irq4", &self.gpio_int0_irq4())
1492            .field("gpio_int0_irq5", &self.gpio_int0_irq5())
1493            .field("gpio_int0_irq6", &self.gpio_int0_irq6())
1494            .field("gpio_int0_irq7", &self.gpio_int0_irq7())
1495            .field("ct32bit2", &self.ct32bit2())
1496            .field("ct32bit4", &self.ct32bit4())
1497            .field("os_event_timer_wu", &self.os_event_timer_wu())
1498            .field("flexspi", &self.flexspi())
1499            .field("flexcomm6", &self.flexcomm6())
1500            .field("flexcomm7", &self.flexcomm7())
1501            .field("sdio0", &self.sdio0())
1502            .field("sdio1", &self.sdio1())
1503            .field("shsgpio_int0", &self.shsgpio_int0())
1504            .field("shsgpio_int1", &self.shsgpio_int1())
1505            .field("i3c0", &self.i3c0())
1506            .field("usb_irq", &self.usb_irq())
1507            .field("usb_needclk", &self.usb_needclk())
1508            .field("dmac1", &self.dmac1())
1509            .field("puf", &self.puf())
1510            .field("powerquad", &self.powerquad())
1511            .field("casper", &self.casper())
1512            .field("pmic", &self.pmic())
1513            .field("sha", &self.sha())
1514            .finish()
1515    }
1516}
1517impl W {
1518    #[doc = "Bit 0 - no description available"]
1519    #[inline(always)]
1520    pub fn rtc_lite0_alarm_or_wakeup(&mut self) -> RtcLite0AlarmOrWakeupW<Starten1Spec> {
1521        RtcLite0AlarmOrWakeupW::new(self, 0)
1522    }
1523    #[doc = "Bit 2 - no description available"]
1524    #[inline(always)]
1525    pub fn mu(&mut self) -> MuW<Starten1Spec> {
1526        MuW::new(self, 2)
1527    }
1528    #[doc = "Bit 3 - no description available"]
1529    #[inline(always)]
1530    pub fn gpio_int0_irq4(&mut self) -> GpioInt0Irq4W<Starten1Spec> {
1531        GpioInt0Irq4W::new(self, 3)
1532    }
1533    #[doc = "Bit 4 - no description available"]
1534    #[inline(always)]
1535    pub fn gpio_int0_irq5(&mut self) -> GpioInt0Irq5W<Starten1Spec> {
1536        GpioInt0Irq5W::new(self, 4)
1537    }
1538    #[doc = "Bit 5 - no description available"]
1539    #[inline(always)]
1540    pub fn gpio_int0_irq6(&mut self) -> GpioInt0Irq6W<Starten1Spec> {
1541        GpioInt0Irq6W::new(self, 5)
1542    }
1543    #[doc = "Bit 6 - no description available"]
1544    #[inline(always)]
1545    pub fn gpio_int0_irq7(&mut self) -> GpioInt0Irq7W<Starten1Spec> {
1546        GpioInt0Irq7W::new(self, 6)
1547    }
1548    #[doc = "Bit 7 - no description available"]
1549    #[inline(always)]
1550    pub fn ct32bit2(&mut self) -> Ct32bit2W<Starten1Spec> {
1551        Ct32bit2W::new(self, 7)
1552    }
1553    #[doc = "Bit 8 - no description available"]
1554    #[inline(always)]
1555    pub fn ct32bit4(&mut self) -> Ct32bit4W<Starten1Spec> {
1556        Ct32bit4W::new(self, 8)
1557    }
1558    #[doc = "Bit 9 - no description available"]
1559    #[inline(always)]
1560    pub fn os_event_timer_wu(&mut self) -> OsEventTimerWuW<Starten1Spec> {
1561        OsEventTimerWuW::new(self, 9)
1562    }
1563    #[doc = "Bit 10 - no description available"]
1564    #[inline(always)]
1565    pub fn flexspi(&mut self) -> FlexspiW<Starten1Spec> {
1566        FlexspiW::new(self, 10)
1567    }
1568    #[doc = "Bit 11 - no description available"]
1569    #[inline(always)]
1570    pub fn flexcomm6(&mut self) -> Flexcomm6W<Starten1Spec> {
1571        Flexcomm6W::new(self, 11)
1572    }
1573    #[doc = "Bit 12 - no description available"]
1574    #[inline(always)]
1575    pub fn flexcomm7(&mut self) -> Flexcomm7W<Starten1Spec> {
1576        Flexcomm7W::new(self, 12)
1577    }
1578    #[doc = "Bit 13 - no description available"]
1579    #[inline(always)]
1580    pub fn sdio0(&mut self) -> Sdio0W<Starten1Spec> {
1581        Sdio0W::new(self, 13)
1582    }
1583    #[doc = "Bit 14 - no description available"]
1584    #[inline(always)]
1585    pub fn sdio1(&mut self) -> Sdio1W<Starten1Spec> {
1586        Sdio1W::new(self, 14)
1587    }
1588    #[doc = "Bit 15 - no description available"]
1589    #[inline(always)]
1590    pub fn shsgpio_int0(&mut self) -> ShsgpioInt0W<Starten1Spec> {
1591        ShsgpioInt0W::new(self, 15)
1592    }
1593    #[doc = "Bit 16 - no description available"]
1594    #[inline(always)]
1595    pub fn shsgpio_int1(&mut self) -> ShsgpioInt1W<Starten1Spec> {
1596        ShsgpioInt1W::new(self, 16)
1597    }
1598    #[doc = "Bit 17 - no description available"]
1599    #[inline(always)]
1600    pub fn i3c0(&mut self) -> I3c0W<Starten1Spec> {
1601        I3c0W::new(self, 17)
1602    }
1603    #[doc = "Bit 18 - no description available"]
1604    #[inline(always)]
1605    pub fn usb_irq(&mut self) -> UsbIrqW<Starten1Spec> {
1606        UsbIrqW::new(self, 18)
1607    }
1608    #[doc = "Bit 19 - no description available"]
1609    #[inline(always)]
1610    pub fn usb_needclk(&mut self) -> UsbNeedclkW<Starten1Spec> {
1611        UsbNeedclkW::new(self, 19)
1612    }
1613    #[doc = "Bit 22 - no description available"]
1614    #[inline(always)]
1615    pub fn dmac1(&mut self) -> Dmac1W<Starten1Spec> {
1616        Dmac1W::new(self, 22)
1617    }
1618    #[doc = "Bit 23 - no description available"]
1619    #[inline(always)]
1620    pub fn puf(&mut self) -> PufW<Starten1Spec> {
1621        PufW::new(self, 23)
1622    }
1623    #[doc = "Bit 24 - no description available"]
1624    #[inline(always)]
1625    pub fn powerquad(&mut self) -> PowerquadW<Starten1Spec> {
1626        PowerquadW::new(self, 24)
1627    }
1628    #[doc = "Bit 25 - no description available"]
1629    #[inline(always)]
1630    pub fn casper(&mut self) -> CasperW<Starten1Spec> {
1631        CasperW::new(self, 25)
1632    }
1633    #[doc = "Bit 26 - no description available"]
1634    #[inline(always)]
1635    pub fn pmic(&mut self) -> PmicW<Starten1Spec> {
1636        PmicW::new(self, 26)
1637    }
1638    #[doc = "Bit 27 - no description available"]
1639    #[inline(always)]
1640    pub fn sha(&mut self) -> ShaW<Starten1Spec> {
1641        ShaW::new(self, 27)
1642    }
1643}
1644#[doc = "Start enable 1\n\nYou can [`read`](crate::Reg::read) this register and get [`starten1::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`starten1::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1645pub struct Starten1Spec;
1646impl crate::RegisterSpec for Starten1Spec {
1647    type Ux = u32;
1648}
1649#[doc = "`read()` method returns [`starten1::R`](R) reader structure"]
1650impl crate::Readable for Starten1Spec {}
1651#[doc = "`write(|w| ..)` method takes [`starten1::W`](W) writer structure"]
1652impl crate::Writable for Starten1Spec {
1653    type Safety = crate::Unsafe;
1654    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1655    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1656}
1657#[doc = "`reset()` method sets STARTEN1 to value 0"]
1658impl crate::Resettable for Starten1Spec {
1659    const RESET_VALUE: u32 = 0;
1660}
mimxrt685s_pac/sysctl0/starten1.rs

mimxrt685s_pac/sysctl0/
starten1.rs
