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}