xmc4100/eru0/
exocon.rs

1#[doc = "Register `EXOCON[%s]` reader"]
2pub type R = crate::R<EXOCON_SPEC>;
3#[doc = "Register `EXOCON[%s]` writer"]
4pub type W = crate::W<EXOCON_SPEC>;
5#[doc = "Internal Trigger Source Selection\n\nValue on reset: 0"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u8)]
8pub enum ISS_A {
9    #[doc = "0: The peripheral trigger function is disabled"]
10    VALUE1 = 0,
11    #[doc = "1: Input ERU_OGUy1 is selected"]
12    VALUE2 = 1,
13    #[doc = "2: Input ERU_OGUy2 is selected"]
14    VALUE3 = 2,
15    #[doc = "3: Input ERU_OGUy3 is selected"]
16    VALUE4 = 3,
17}
18impl From<ISS_A> for u8 {
19    #[inline(always)]
20    fn from(variant: ISS_A) -> Self {
21        variant as _
22    }
23}
24impl crate::FieldSpec for ISS_A {
25    type Ux = u8;
26}
27impl crate::IsEnum for ISS_A {}
28#[doc = "Field `ISS` reader - Internal Trigger Source Selection"]
29pub type ISS_R = crate::FieldReader<ISS_A>;
30impl ISS_R {
31    #[doc = "Get enumerated values variant"]
32    #[inline(always)]
33    pub const fn variant(&self) -> ISS_A {
34        match self.bits {
35            0 => ISS_A::VALUE1,
36            1 => ISS_A::VALUE2,
37            2 => ISS_A::VALUE3,
38            3 => ISS_A::VALUE4,
39            _ => unreachable!(),
40        }
41    }
42    #[doc = "The peripheral trigger function is disabled"]
43    #[inline(always)]
44    pub fn is_value1(&self) -> bool {
45        *self == ISS_A::VALUE1
46    }
47    #[doc = "Input ERU_OGUy1 is selected"]
48    #[inline(always)]
49    pub fn is_value2(&self) -> bool {
50        *self == ISS_A::VALUE2
51    }
52    #[doc = "Input ERU_OGUy2 is selected"]
53    #[inline(always)]
54    pub fn is_value3(&self) -> bool {
55        *self == ISS_A::VALUE3
56    }
57    #[doc = "Input ERU_OGUy3 is selected"]
58    #[inline(always)]
59    pub fn is_value4(&self) -> bool {
60        *self == ISS_A::VALUE4
61    }
62}
63#[doc = "Field `ISS` writer - Internal Trigger Source Selection"]
64pub type ISS_W<'a, REG> = crate::FieldWriter<'a, REG, 2, ISS_A, crate::Safe>;
65impl<'a, REG> ISS_W<'a, REG>
66where
67    REG: crate::Writable + crate::RegisterSpec,
68    REG::Ux: From<u8>,
69{
70    #[doc = "The peripheral trigger function is disabled"]
71    #[inline(always)]
72    pub fn value1(self) -> &'a mut crate::W<REG> {
73        self.variant(ISS_A::VALUE1)
74    }
75    #[doc = "Input ERU_OGUy1 is selected"]
76    #[inline(always)]
77    pub fn value2(self) -> &'a mut crate::W<REG> {
78        self.variant(ISS_A::VALUE2)
79    }
80    #[doc = "Input ERU_OGUy2 is selected"]
81    #[inline(always)]
82    pub fn value3(self) -> &'a mut crate::W<REG> {
83        self.variant(ISS_A::VALUE3)
84    }
85    #[doc = "Input ERU_OGUy3 is selected"]
86    #[inline(always)]
87    pub fn value4(self) -> &'a mut crate::W<REG> {
88        self.variant(ISS_A::VALUE4)
89    }
90}
91#[doc = "Gating Event Enable\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq, Eq)]
93pub enum GEEN_A {
94    #[doc = "0: The event detection is disabled"]
95    VALUE1 = 0,
96    #[doc = "1: The event detection is enabled"]
97    VALUE2 = 1,
98}
99impl From<GEEN_A> for bool {
100    #[inline(always)]
101    fn from(variant: GEEN_A) -> Self {
102        variant as u8 != 0
103    }
104}
105#[doc = "Field `GEEN` reader - Gating Event Enable"]
106pub type GEEN_R = crate::BitReader<GEEN_A>;
107impl GEEN_R {
108    #[doc = "Get enumerated values variant"]
109    #[inline(always)]
110    pub const fn variant(&self) -> GEEN_A {
111        match self.bits {
112            false => GEEN_A::VALUE1,
113            true => GEEN_A::VALUE2,
114        }
115    }
116    #[doc = "The event detection is disabled"]
117    #[inline(always)]
118    pub fn is_value1(&self) -> bool {
119        *self == GEEN_A::VALUE1
120    }
121    #[doc = "The event detection is enabled"]
122    #[inline(always)]
123    pub fn is_value2(&self) -> bool {
124        *self == GEEN_A::VALUE2
125    }
126}
127#[doc = "Field `GEEN` writer - Gating Event Enable"]
128pub type GEEN_W<'a, REG> = crate::BitWriter<'a, REG, GEEN_A>;
129impl<'a, REG> GEEN_W<'a, REG>
130where
131    REG: crate::Writable + crate::RegisterSpec,
132{
133    #[doc = "The event detection is disabled"]
134    #[inline(always)]
135    pub fn value1(self) -> &'a mut crate::W<REG> {
136        self.variant(GEEN_A::VALUE1)
137    }
138    #[doc = "The event detection is enabled"]
139    #[inline(always)]
140    pub fn value2(self) -> &'a mut crate::W<REG> {
141        self.variant(GEEN_A::VALUE2)
142    }
143}
144#[doc = "Pattern Detection Result Flag\n\nValue on reset: 1"]
145#[derive(Clone, Copy, Debug, PartialEq, Eq)]
146pub enum PDR_A {
147    #[doc = "0: A pattern miss is detected"]
148    VALUE1 = 0,
149    #[doc = "1: A pattern match is detected"]
150    VALUE2 = 1,
151}
152impl From<PDR_A> for bool {
153    #[inline(always)]
154    fn from(variant: PDR_A) -> Self {
155        variant as u8 != 0
156    }
157}
158#[doc = "Field `PDR` reader - Pattern Detection Result Flag"]
159pub type PDR_R = crate::BitReader<PDR_A>;
160impl PDR_R {
161    #[doc = "Get enumerated values variant"]
162    #[inline(always)]
163    pub const fn variant(&self) -> PDR_A {
164        match self.bits {
165            false => PDR_A::VALUE1,
166            true => PDR_A::VALUE2,
167        }
168    }
169    #[doc = "A pattern miss is detected"]
170    #[inline(always)]
171    pub fn is_value1(&self) -> bool {
172        *self == PDR_A::VALUE1
173    }
174    #[doc = "A pattern match is detected"]
175    #[inline(always)]
176    pub fn is_value2(&self) -> bool {
177        *self == PDR_A::VALUE2
178    }
179}
180#[doc = "Gating Selection for Pattern Detection Result\n\nValue on reset: 0"]
181#[derive(Clone, Copy, Debug, PartialEq, Eq)]
182#[repr(u8)]
183pub enum GP_A {
184    #[doc = "0: ERU_GOUTy is always disabled and ERU_IOUTy can not be activated"]
185    VALUE1 = 0,
186    #[doc = "1: ERU_GOUTy is always enabled and ERU_IOUTy becomes activated with each activation of ERU_TOUTy"]
187    VALUE2 = 1,
188    #[doc = "2: ERU_GOUTy is equal to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is detected (pattern match PDR = 1)"]
189    VALUE3 = 2,
190    #[doc = "3: ERU_GOUTy is inverted to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is not detected (pattern miss PDR = 0)"]
191    VALUE4 = 3,
192}
193impl From<GP_A> for u8 {
194    #[inline(always)]
195    fn from(variant: GP_A) -> Self {
196        variant as _
197    }
198}
199impl crate::FieldSpec for GP_A {
200    type Ux = u8;
201}
202impl crate::IsEnum for GP_A {}
203#[doc = "Field `GP` reader - Gating Selection for Pattern Detection Result"]
204pub type GP_R = crate::FieldReader<GP_A>;
205impl GP_R {
206    #[doc = "Get enumerated values variant"]
207    #[inline(always)]
208    pub const fn variant(&self) -> GP_A {
209        match self.bits {
210            0 => GP_A::VALUE1,
211            1 => GP_A::VALUE2,
212            2 => GP_A::VALUE3,
213            3 => GP_A::VALUE4,
214            _ => unreachable!(),
215        }
216    }
217    #[doc = "ERU_GOUTy is always disabled and ERU_IOUTy can not be activated"]
218    #[inline(always)]
219    pub fn is_value1(&self) -> bool {
220        *self == GP_A::VALUE1
221    }
222    #[doc = "ERU_GOUTy is always enabled and ERU_IOUTy becomes activated with each activation of ERU_TOUTy"]
223    #[inline(always)]
224    pub fn is_value2(&self) -> bool {
225        *self == GP_A::VALUE2
226    }
227    #[doc = "ERU_GOUTy is equal to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is detected (pattern match PDR = 1)"]
228    #[inline(always)]
229    pub fn is_value3(&self) -> bool {
230        *self == GP_A::VALUE3
231    }
232    #[doc = "ERU_GOUTy is inverted to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is not detected (pattern miss PDR = 0)"]
233    #[inline(always)]
234    pub fn is_value4(&self) -> bool {
235        *self == GP_A::VALUE4
236    }
237}
238#[doc = "Field `GP` writer - Gating Selection for Pattern Detection Result"]
239pub type GP_W<'a, REG> = crate::FieldWriter<'a, REG, 2, GP_A, crate::Safe>;
240impl<'a, REG> GP_W<'a, REG>
241where
242    REG: crate::Writable + crate::RegisterSpec,
243    REG::Ux: From<u8>,
244{
245    #[doc = "ERU_GOUTy is always disabled and ERU_IOUTy can not be activated"]
246    #[inline(always)]
247    pub fn value1(self) -> &'a mut crate::W<REG> {
248        self.variant(GP_A::VALUE1)
249    }
250    #[doc = "ERU_GOUTy is always enabled and ERU_IOUTy becomes activated with each activation of ERU_TOUTy"]
251    #[inline(always)]
252    pub fn value2(self) -> &'a mut crate::W<REG> {
253        self.variant(GP_A::VALUE2)
254    }
255    #[doc = "ERU_GOUTy is equal to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is detected (pattern match PDR = 1)"]
256    #[inline(always)]
257    pub fn value3(self) -> &'a mut crate::W<REG> {
258        self.variant(GP_A::VALUE3)
259    }
260    #[doc = "ERU_GOUTy is inverted to ERU_PDOUTy and ERU_IOUTy becomes activated with an activation of ERU_TOUTy while the desired pattern is not detected (pattern miss PDR = 0)"]
261    #[inline(always)]
262    pub fn value4(self) -> &'a mut crate::W<REG> {
263        self.variant(GP_A::VALUE4)
264    }
265}
266#[doc = "Pattern Detection Enable for ETL0\n\nValue on reset: 0"]
267#[derive(Clone, Copy, Debug, PartialEq, Eq)]
268pub enum IPEN0_A {
269    #[doc = "0: Flag EXICONx.FL is excluded from the pattern detection"]
270    VALUE1 = 0,
271    #[doc = "1: Flag EXICONx.FL is included in the pattern detection"]
272    VALUE2 = 1,
273}
274impl From<IPEN0_A> for bool {
275    #[inline(always)]
276    fn from(variant: IPEN0_A) -> Self {
277        variant as u8 != 0
278    }
279}
280#[doc = "Field `IPEN0` reader - Pattern Detection Enable for ETL0"]
281pub type IPEN0_R = crate::BitReader<IPEN0_A>;
282impl IPEN0_R {
283    #[doc = "Get enumerated values variant"]
284    #[inline(always)]
285    pub const fn variant(&self) -> IPEN0_A {
286        match self.bits {
287            false => IPEN0_A::VALUE1,
288            true => IPEN0_A::VALUE2,
289        }
290    }
291    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
292    #[inline(always)]
293    pub fn is_value1(&self) -> bool {
294        *self == IPEN0_A::VALUE1
295    }
296    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
297    #[inline(always)]
298    pub fn is_value2(&self) -> bool {
299        *self == IPEN0_A::VALUE2
300    }
301}
302#[doc = "Field `IPEN0` writer - Pattern Detection Enable for ETL0"]
303pub type IPEN0_W<'a, REG> = crate::BitWriter<'a, REG, IPEN0_A>;
304impl<'a, REG> IPEN0_W<'a, REG>
305where
306    REG: crate::Writable + crate::RegisterSpec,
307{
308    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
309    #[inline(always)]
310    pub fn value1(self) -> &'a mut crate::W<REG> {
311        self.variant(IPEN0_A::VALUE1)
312    }
313    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
314    #[inline(always)]
315    pub fn value2(self) -> &'a mut crate::W<REG> {
316        self.variant(IPEN0_A::VALUE2)
317    }
318}
319#[doc = "Pattern Detection Enable for ETL1\n\nValue on reset: 0"]
320#[derive(Clone, Copy, Debug, PartialEq, Eq)]
321pub enum IPEN1_A {
322    #[doc = "0: Flag EXICONx.FL is excluded from the pattern detection"]
323    VALUE1 = 0,
324    #[doc = "1: Flag EXICONx.FL is included in the pattern detection"]
325    VALUE2 = 1,
326}
327impl From<IPEN1_A> for bool {
328    #[inline(always)]
329    fn from(variant: IPEN1_A) -> Self {
330        variant as u8 != 0
331    }
332}
333#[doc = "Field `IPEN1` reader - Pattern Detection Enable for ETL1"]
334pub type IPEN1_R = crate::BitReader<IPEN1_A>;
335impl IPEN1_R {
336    #[doc = "Get enumerated values variant"]
337    #[inline(always)]
338    pub const fn variant(&self) -> IPEN1_A {
339        match self.bits {
340            false => IPEN1_A::VALUE1,
341            true => IPEN1_A::VALUE2,
342        }
343    }
344    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
345    #[inline(always)]
346    pub fn is_value1(&self) -> bool {
347        *self == IPEN1_A::VALUE1
348    }
349    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
350    #[inline(always)]
351    pub fn is_value2(&self) -> bool {
352        *self == IPEN1_A::VALUE2
353    }
354}
355#[doc = "Field `IPEN1` writer - Pattern Detection Enable for ETL1"]
356pub type IPEN1_W<'a, REG> = crate::BitWriter<'a, REG, IPEN1_A>;
357impl<'a, REG> IPEN1_W<'a, REG>
358where
359    REG: crate::Writable + crate::RegisterSpec,
360{
361    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
362    #[inline(always)]
363    pub fn value1(self) -> &'a mut crate::W<REG> {
364        self.variant(IPEN1_A::VALUE1)
365    }
366    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
367    #[inline(always)]
368    pub fn value2(self) -> &'a mut crate::W<REG> {
369        self.variant(IPEN1_A::VALUE2)
370    }
371}
372#[doc = "Pattern Detection Enable for ETL2\n\nValue on reset: 0"]
373#[derive(Clone, Copy, Debug, PartialEq, Eq)]
374pub enum IPEN2_A {
375    #[doc = "0: Flag EXICONx.FL is excluded from the pattern detection"]
376    VALUE1 = 0,
377    #[doc = "1: Flag EXICONx.FL is included in the pattern detection"]
378    VALUE2 = 1,
379}
380impl From<IPEN2_A> for bool {
381    #[inline(always)]
382    fn from(variant: IPEN2_A) -> Self {
383        variant as u8 != 0
384    }
385}
386#[doc = "Field `IPEN2` reader - Pattern Detection Enable for ETL2"]
387pub type IPEN2_R = crate::BitReader<IPEN2_A>;
388impl IPEN2_R {
389    #[doc = "Get enumerated values variant"]
390    #[inline(always)]
391    pub const fn variant(&self) -> IPEN2_A {
392        match self.bits {
393            false => IPEN2_A::VALUE1,
394            true => IPEN2_A::VALUE2,
395        }
396    }
397    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
398    #[inline(always)]
399    pub fn is_value1(&self) -> bool {
400        *self == IPEN2_A::VALUE1
401    }
402    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
403    #[inline(always)]
404    pub fn is_value2(&self) -> bool {
405        *self == IPEN2_A::VALUE2
406    }
407}
408#[doc = "Field `IPEN2` writer - Pattern Detection Enable for ETL2"]
409pub type IPEN2_W<'a, REG> = crate::BitWriter<'a, REG, IPEN2_A>;
410impl<'a, REG> IPEN2_W<'a, REG>
411where
412    REG: crate::Writable + crate::RegisterSpec,
413{
414    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
415    #[inline(always)]
416    pub fn value1(self) -> &'a mut crate::W<REG> {
417        self.variant(IPEN2_A::VALUE1)
418    }
419    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
420    #[inline(always)]
421    pub fn value2(self) -> &'a mut crate::W<REG> {
422        self.variant(IPEN2_A::VALUE2)
423    }
424}
425#[doc = "Pattern Detection Enable for ETL3\n\nValue on reset: 0"]
426#[derive(Clone, Copy, Debug, PartialEq, Eq)]
427pub enum IPEN3_A {
428    #[doc = "0: Flag EXICONx.FL is excluded from the pattern detection"]
429    VALUE1 = 0,
430    #[doc = "1: Flag EXICONx.FL is included in the pattern detection"]
431    VALUE2 = 1,
432}
433impl From<IPEN3_A> for bool {
434    #[inline(always)]
435    fn from(variant: IPEN3_A) -> Self {
436        variant as u8 != 0
437    }
438}
439#[doc = "Field `IPEN3` reader - Pattern Detection Enable for ETL3"]
440pub type IPEN3_R = crate::BitReader<IPEN3_A>;
441impl IPEN3_R {
442    #[doc = "Get enumerated values variant"]
443    #[inline(always)]
444    pub const fn variant(&self) -> IPEN3_A {
445        match self.bits {
446            false => IPEN3_A::VALUE1,
447            true => IPEN3_A::VALUE2,
448        }
449    }
450    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
451    #[inline(always)]
452    pub fn is_value1(&self) -> bool {
453        *self == IPEN3_A::VALUE1
454    }
455    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
456    #[inline(always)]
457    pub fn is_value2(&self) -> bool {
458        *self == IPEN3_A::VALUE2
459    }
460}
461#[doc = "Field `IPEN3` writer - Pattern Detection Enable for ETL3"]
462pub type IPEN3_W<'a, REG> = crate::BitWriter<'a, REG, IPEN3_A>;
463impl<'a, REG> IPEN3_W<'a, REG>
464where
465    REG: crate::Writable + crate::RegisterSpec,
466{
467    #[doc = "Flag EXICONx.FL is excluded from the pattern detection"]
468    #[inline(always)]
469    pub fn value1(self) -> &'a mut crate::W<REG> {
470        self.variant(IPEN3_A::VALUE1)
471    }
472    #[doc = "Flag EXICONx.FL is included in the pattern detection"]
473    #[inline(always)]
474    pub fn value2(self) -> &'a mut crate::W<REG> {
475        self.variant(IPEN3_A::VALUE2)
476    }
477}
478impl R {
479    #[doc = "Bits 0:1 - Internal Trigger Source Selection"]
480    #[inline(always)]
481    pub fn iss(&self) -> ISS_R {
482        ISS_R::new((self.bits & 3) as u8)
483    }
484    #[doc = "Bit 2 - Gating Event Enable"]
485    #[inline(always)]
486    pub fn geen(&self) -> GEEN_R {
487        GEEN_R::new(((self.bits >> 2) & 1) != 0)
488    }
489    #[doc = "Bit 3 - Pattern Detection Result Flag"]
490    #[inline(always)]
491    pub fn pdr(&self) -> PDR_R {
492        PDR_R::new(((self.bits >> 3) & 1) != 0)
493    }
494    #[doc = "Bits 4:5 - Gating Selection for Pattern Detection Result"]
495    #[inline(always)]
496    pub fn gp(&self) -> GP_R {
497        GP_R::new(((self.bits >> 4) & 3) as u8)
498    }
499    #[doc = "Bit 12 - Pattern Detection Enable for ETL0"]
500    #[inline(always)]
501    pub fn ipen0(&self) -> IPEN0_R {
502        IPEN0_R::new(((self.bits >> 12) & 1) != 0)
503    }
504    #[doc = "Bit 13 - Pattern Detection Enable for ETL1"]
505    #[inline(always)]
506    pub fn ipen1(&self) -> IPEN1_R {
507        IPEN1_R::new(((self.bits >> 13) & 1) != 0)
508    }
509    #[doc = "Bit 14 - Pattern Detection Enable for ETL2"]
510    #[inline(always)]
511    pub fn ipen2(&self) -> IPEN2_R {
512        IPEN2_R::new(((self.bits >> 14) & 1) != 0)
513    }
514    #[doc = "Bit 15 - Pattern Detection Enable for ETL3"]
515    #[inline(always)]
516    pub fn ipen3(&self) -> IPEN3_R {
517        IPEN3_R::new(((self.bits >> 15) & 1) != 0)
518    }
519}
520impl W {
521    #[doc = "Bits 0:1 - Internal Trigger Source Selection"]
522    #[inline(always)]
523    pub fn iss(&mut self) -> ISS_W<EXOCON_SPEC> {
524        ISS_W::new(self, 0)
525    }
526    #[doc = "Bit 2 - Gating Event Enable"]
527    #[inline(always)]
528    pub fn geen(&mut self) -> GEEN_W<EXOCON_SPEC> {
529        GEEN_W::new(self, 2)
530    }
531    #[doc = "Bits 4:5 - Gating Selection for Pattern Detection Result"]
532    #[inline(always)]
533    pub fn gp(&mut self) -> GP_W<EXOCON_SPEC> {
534        GP_W::new(self, 4)
535    }
536    #[doc = "Bit 12 - Pattern Detection Enable for ETL0"]
537    #[inline(always)]
538    pub fn ipen0(&mut self) -> IPEN0_W<EXOCON_SPEC> {
539        IPEN0_W::new(self, 12)
540    }
541    #[doc = "Bit 13 - Pattern Detection Enable for ETL1"]
542    #[inline(always)]
543    pub fn ipen1(&mut self) -> IPEN1_W<EXOCON_SPEC> {
544        IPEN1_W::new(self, 13)
545    }
546    #[doc = "Bit 14 - Pattern Detection Enable for ETL2"]
547    #[inline(always)]
548    pub fn ipen2(&mut self) -> IPEN2_W<EXOCON_SPEC> {
549        IPEN2_W::new(self, 14)
550    }
551    #[doc = "Bit 15 - Pattern Detection Enable for ETL3"]
552    #[inline(always)]
553    pub fn ipen3(&mut self) -> IPEN3_W<EXOCON_SPEC> {
554        IPEN3_W::new(self, 15)
555    }
556}
557#[doc = "Event Output Trigger Control\n\nYou can [`read`](crate::Reg::read) this register and get [`exocon::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`exocon::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
558pub struct EXOCON_SPEC;
559impl crate::RegisterSpec for EXOCON_SPEC {
560    type Ux = u32;
561}
562#[doc = "`read()` method returns [`exocon::R`](R) reader structure"]
563impl crate::Readable for EXOCON_SPEC {}
564#[doc = "`write(|w| ..)` method takes [`exocon::W`](W) writer structure"]
565impl crate::Writable for EXOCON_SPEC {
566    type Safety = crate::Unsafe;
567    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
568    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
569}
570#[doc = "`reset()` method sets EXOCON[%s]
571to value 0x08"]
572impl crate::Resettable for EXOCON_SPEC {
573    const RESET_VALUE: u32 = 0x08;
574}