efm32gg12b_pac/efm32gg12b830/wtimer0/
routeloc0.rs1#[doc = "Register `ROUTELOC0` reader"]
2pub struct R(crate::R<ROUTELOC0_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<ROUTELOC0_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<ROUTELOC0_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<ROUTELOC0_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `ROUTELOC0` writer"]
17pub struct W(crate::W<ROUTELOC0_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<ROUTELOC0_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<ROUTELOC0_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<ROUTELOC0_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `CC0LOC` reader - I/O Location"]
38pub type CC0LOC_R = crate::FieldReader<u8, CC0LOC_A>;
39#[doc = "I/O Location\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum CC0LOC_A {
43 #[doc = "0: Location 0"]
44 LOC0 = 0,
45 #[doc = "1: Location 1"]
46 LOC1 = 1,
47 #[doc = "2: Location 2"]
48 LOC2 = 2,
49 #[doc = "3: Location 3"]
50 LOC3 = 3,
51 #[doc = "4: Location 4"]
52 LOC4 = 4,
53 #[doc = "5: Location 5"]
54 LOC5 = 5,
55 #[doc = "6: Location 6"]
56 LOC6 = 6,
57 #[doc = "7: Location 7"]
58 LOC7 = 7,
59}
60impl From<CC0LOC_A> for u8 {
61 #[inline(always)]
62 fn from(variant: CC0LOC_A) -> Self {
63 variant as _
64 }
65}
66impl CC0LOC_R {
67 #[doc = "Get enumerated values variant"]
68 #[inline(always)]
69 pub fn variant(&self) -> Option<CC0LOC_A> {
70 match self.bits {
71 0 => Some(CC0LOC_A::LOC0),
72 1 => Some(CC0LOC_A::LOC1),
73 2 => Some(CC0LOC_A::LOC2),
74 3 => Some(CC0LOC_A::LOC3),
75 4 => Some(CC0LOC_A::LOC4),
76 5 => Some(CC0LOC_A::LOC5),
77 6 => Some(CC0LOC_A::LOC6),
78 7 => Some(CC0LOC_A::LOC7),
79 _ => None,
80 }
81 }
82 #[doc = "Checks if the value of the field is `LOC0`"]
83 #[inline(always)]
84 pub fn is_loc0(&self) -> bool {
85 *self == CC0LOC_A::LOC0
86 }
87 #[doc = "Checks if the value of the field is `LOC1`"]
88 #[inline(always)]
89 pub fn is_loc1(&self) -> bool {
90 *self == CC0LOC_A::LOC1
91 }
92 #[doc = "Checks if the value of the field is `LOC2`"]
93 #[inline(always)]
94 pub fn is_loc2(&self) -> bool {
95 *self == CC0LOC_A::LOC2
96 }
97 #[doc = "Checks if the value of the field is `LOC3`"]
98 #[inline(always)]
99 pub fn is_loc3(&self) -> bool {
100 *self == CC0LOC_A::LOC3
101 }
102 #[doc = "Checks if the value of the field is `LOC4`"]
103 #[inline(always)]
104 pub fn is_loc4(&self) -> bool {
105 *self == CC0LOC_A::LOC4
106 }
107 #[doc = "Checks if the value of the field is `LOC5`"]
108 #[inline(always)]
109 pub fn is_loc5(&self) -> bool {
110 *self == CC0LOC_A::LOC5
111 }
112 #[doc = "Checks if the value of the field is `LOC6`"]
113 #[inline(always)]
114 pub fn is_loc6(&self) -> bool {
115 *self == CC0LOC_A::LOC6
116 }
117 #[doc = "Checks if the value of the field is `LOC7`"]
118 #[inline(always)]
119 pub fn is_loc7(&self) -> bool {
120 *self == CC0LOC_A::LOC7
121 }
122}
123#[doc = "Field `CC0LOC` writer - I/O Location"]
124pub type CC0LOC_W<'a, const O: u8> =
125 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC0LOC_A, 6, O>;
126impl<'a, const O: u8> CC0LOC_W<'a, O> {
127 #[doc = "Location 0"]
128 #[inline(always)]
129 pub fn loc0(self) -> &'a mut W {
130 self.variant(CC0LOC_A::LOC0)
131 }
132 #[doc = "Location 1"]
133 #[inline(always)]
134 pub fn loc1(self) -> &'a mut W {
135 self.variant(CC0LOC_A::LOC1)
136 }
137 #[doc = "Location 2"]
138 #[inline(always)]
139 pub fn loc2(self) -> &'a mut W {
140 self.variant(CC0LOC_A::LOC2)
141 }
142 #[doc = "Location 3"]
143 #[inline(always)]
144 pub fn loc3(self) -> &'a mut W {
145 self.variant(CC0LOC_A::LOC3)
146 }
147 #[doc = "Location 4"]
148 #[inline(always)]
149 pub fn loc4(self) -> &'a mut W {
150 self.variant(CC0LOC_A::LOC4)
151 }
152 #[doc = "Location 5"]
153 #[inline(always)]
154 pub fn loc5(self) -> &'a mut W {
155 self.variant(CC0LOC_A::LOC5)
156 }
157 #[doc = "Location 6"]
158 #[inline(always)]
159 pub fn loc6(self) -> &'a mut W {
160 self.variant(CC0LOC_A::LOC6)
161 }
162 #[doc = "Location 7"]
163 #[inline(always)]
164 pub fn loc7(self) -> &'a mut W {
165 self.variant(CC0LOC_A::LOC7)
166 }
167}
168#[doc = "Field `CC1LOC` reader - I/O Location"]
169pub type CC1LOC_R = crate::FieldReader<u8, CC1LOC_A>;
170#[doc = "I/O Location\n\nValue on reset: 0"]
171#[derive(Clone, Copy, Debug, PartialEq, Eq)]
172#[repr(u8)]
173pub enum CC1LOC_A {
174 #[doc = "0: Location 0"]
175 LOC0 = 0,
176 #[doc = "1: Location 1"]
177 LOC1 = 1,
178 #[doc = "2: Location 2"]
179 LOC2 = 2,
180 #[doc = "3: Location 3"]
181 LOC3 = 3,
182 #[doc = "4: Location 4"]
183 LOC4 = 4,
184 #[doc = "5: Location 5"]
185 LOC5 = 5,
186 #[doc = "6: Location 6"]
187 LOC6 = 6,
188 #[doc = "7: Location 7"]
189 LOC7 = 7,
190}
191impl From<CC1LOC_A> for u8 {
192 #[inline(always)]
193 fn from(variant: CC1LOC_A) -> Self {
194 variant as _
195 }
196}
197impl CC1LOC_R {
198 #[doc = "Get enumerated values variant"]
199 #[inline(always)]
200 pub fn variant(&self) -> Option<CC1LOC_A> {
201 match self.bits {
202 0 => Some(CC1LOC_A::LOC0),
203 1 => Some(CC1LOC_A::LOC1),
204 2 => Some(CC1LOC_A::LOC2),
205 3 => Some(CC1LOC_A::LOC3),
206 4 => Some(CC1LOC_A::LOC4),
207 5 => Some(CC1LOC_A::LOC5),
208 6 => Some(CC1LOC_A::LOC6),
209 7 => Some(CC1LOC_A::LOC7),
210 _ => None,
211 }
212 }
213 #[doc = "Checks if the value of the field is `LOC0`"]
214 #[inline(always)]
215 pub fn is_loc0(&self) -> bool {
216 *self == CC1LOC_A::LOC0
217 }
218 #[doc = "Checks if the value of the field is `LOC1`"]
219 #[inline(always)]
220 pub fn is_loc1(&self) -> bool {
221 *self == CC1LOC_A::LOC1
222 }
223 #[doc = "Checks if the value of the field is `LOC2`"]
224 #[inline(always)]
225 pub fn is_loc2(&self) -> bool {
226 *self == CC1LOC_A::LOC2
227 }
228 #[doc = "Checks if the value of the field is `LOC3`"]
229 #[inline(always)]
230 pub fn is_loc3(&self) -> bool {
231 *self == CC1LOC_A::LOC3
232 }
233 #[doc = "Checks if the value of the field is `LOC4`"]
234 #[inline(always)]
235 pub fn is_loc4(&self) -> bool {
236 *self == CC1LOC_A::LOC4
237 }
238 #[doc = "Checks if the value of the field is `LOC5`"]
239 #[inline(always)]
240 pub fn is_loc5(&self) -> bool {
241 *self == CC1LOC_A::LOC5
242 }
243 #[doc = "Checks if the value of the field is `LOC6`"]
244 #[inline(always)]
245 pub fn is_loc6(&self) -> bool {
246 *self == CC1LOC_A::LOC6
247 }
248 #[doc = "Checks if the value of the field is `LOC7`"]
249 #[inline(always)]
250 pub fn is_loc7(&self) -> bool {
251 *self == CC1LOC_A::LOC7
252 }
253}
254#[doc = "Field `CC1LOC` writer - I/O Location"]
255pub type CC1LOC_W<'a, const O: u8> =
256 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC1LOC_A, 6, O>;
257impl<'a, const O: u8> CC1LOC_W<'a, O> {
258 #[doc = "Location 0"]
259 #[inline(always)]
260 pub fn loc0(self) -> &'a mut W {
261 self.variant(CC1LOC_A::LOC0)
262 }
263 #[doc = "Location 1"]
264 #[inline(always)]
265 pub fn loc1(self) -> &'a mut W {
266 self.variant(CC1LOC_A::LOC1)
267 }
268 #[doc = "Location 2"]
269 #[inline(always)]
270 pub fn loc2(self) -> &'a mut W {
271 self.variant(CC1LOC_A::LOC2)
272 }
273 #[doc = "Location 3"]
274 #[inline(always)]
275 pub fn loc3(self) -> &'a mut W {
276 self.variant(CC1LOC_A::LOC3)
277 }
278 #[doc = "Location 4"]
279 #[inline(always)]
280 pub fn loc4(self) -> &'a mut W {
281 self.variant(CC1LOC_A::LOC4)
282 }
283 #[doc = "Location 5"]
284 #[inline(always)]
285 pub fn loc5(self) -> &'a mut W {
286 self.variant(CC1LOC_A::LOC5)
287 }
288 #[doc = "Location 6"]
289 #[inline(always)]
290 pub fn loc6(self) -> &'a mut W {
291 self.variant(CC1LOC_A::LOC6)
292 }
293 #[doc = "Location 7"]
294 #[inline(always)]
295 pub fn loc7(self) -> &'a mut W {
296 self.variant(CC1LOC_A::LOC7)
297 }
298}
299#[doc = "Field `CC2LOC` reader - I/O Location"]
300pub type CC2LOC_R = crate::FieldReader<u8, CC2LOC_A>;
301#[doc = "I/O Location\n\nValue on reset: 0"]
302#[derive(Clone, Copy, Debug, PartialEq, Eq)]
303#[repr(u8)]
304pub enum CC2LOC_A {
305 #[doc = "0: Location 0"]
306 LOC0 = 0,
307 #[doc = "1: Location 1"]
308 LOC1 = 1,
309 #[doc = "2: Location 2"]
310 LOC2 = 2,
311 #[doc = "3: Location 3"]
312 LOC3 = 3,
313 #[doc = "4: Location 4"]
314 LOC4 = 4,
315 #[doc = "5: Location 5"]
316 LOC5 = 5,
317 #[doc = "6: Location 6"]
318 LOC6 = 6,
319 #[doc = "7: Location 7"]
320 LOC7 = 7,
321}
322impl From<CC2LOC_A> for u8 {
323 #[inline(always)]
324 fn from(variant: CC2LOC_A) -> Self {
325 variant as _
326 }
327}
328impl CC2LOC_R {
329 #[doc = "Get enumerated values variant"]
330 #[inline(always)]
331 pub fn variant(&self) -> Option<CC2LOC_A> {
332 match self.bits {
333 0 => Some(CC2LOC_A::LOC0),
334 1 => Some(CC2LOC_A::LOC1),
335 2 => Some(CC2LOC_A::LOC2),
336 3 => Some(CC2LOC_A::LOC3),
337 4 => Some(CC2LOC_A::LOC4),
338 5 => Some(CC2LOC_A::LOC5),
339 6 => Some(CC2LOC_A::LOC6),
340 7 => Some(CC2LOC_A::LOC7),
341 _ => None,
342 }
343 }
344 #[doc = "Checks if the value of the field is `LOC0`"]
345 #[inline(always)]
346 pub fn is_loc0(&self) -> bool {
347 *self == CC2LOC_A::LOC0
348 }
349 #[doc = "Checks if the value of the field is `LOC1`"]
350 #[inline(always)]
351 pub fn is_loc1(&self) -> bool {
352 *self == CC2LOC_A::LOC1
353 }
354 #[doc = "Checks if the value of the field is `LOC2`"]
355 #[inline(always)]
356 pub fn is_loc2(&self) -> bool {
357 *self == CC2LOC_A::LOC2
358 }
359 #[doc = "Checks if the value of the field is `LOC3`"]
360 #[inline(always)]
361 pub fn is_loc3(&self) -> bool {
362 *self == CC2LOC_A::LOC3
363 }
364 #[doc = "Checks if the value of the field is `LOC4`"]
365 #[inline(always)]
366 pub fn is_loc4(&self) -> bool {
367 *self == CC2LOC_A::LOC4
368 }
369 #[doc = "Checks if the value of the field is `LOC5`"]
370 #[inline(always)]
371 pub fn is_loc5(&self) -> bool {
372 *self == CC2LOC_A::LOC5
373 }
374 #[doc = "Checks if the value of the field is `LOC6`"]
375 #[inline(always)]
376 pub fn is_loc6(&self) -> bool {
377 *self == CC2LOC_A::LOC6
378 }
379 #[doc = "Checks if the value of the field is `LOC7`"]
380 #[inline(always)]
381 pub fn is_loc7(&self) -> bool {
382 *self == CC2LOC_A::LOC7
383 }
384}
385#[doc = "Field `CC2LOC` writer - I/O Location"]
386pub type CC2LOC_W<'a, const O: u8> =
387 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC2LOC_A, 6, O>;
388impl<'a, const O: u8> CC2LOC_W<'a, O> {
389 #[doc = "Location 0"]
390 #[inline(always)]
391 pub fn loc0(self) -> &'a mut W {
392 self.variant(CC2LOC_A::LOC0)
393 }
394 #[doc = "Location 1"]
395 #[inline(always)]
396 pub fn loc1(self) -> &'a mut W {
397 self.variant(CC2LOC_A::LOC1)
398 }
399 #[doc = "Location 2"]
400 #[inline(always)]
401 pub fn loc2(self) -> &'a mut W {
402 self.variant(CC2LOC_A::LOC2)
403 }
404 #[doc = "Location 3"]
405 #[inline(always)]
406 pub fn loc3(self) -> &'a mut W {
407 self.variant(CC2LOC_A::LOC3)
408 }
409 #[doc = "Location 4"]
410 #[inline(always)]
411 pub fn loc4(self) -> &'a mut W {
412 self.variant(CC2LOC_A::LOC4)
413 }
414 #[doc = "Location 5"]
415 #[inline(always)]
416 pub fn loc5(self) -> &'a mut W {
417 self.variant(CC2LOC_A::LOC5)
418 }
419 #[doc = "Location 6"]
420 #[inline(always)]
421 pub fn loc6(self) -> &'a mut W {
422 self.variant(CC2LOC_A::LOC6)
423 }
424 #[doc = "Location 7"]
425 #[inline(always)]
426 pub fn loc7(self) -> &'a mut W {
427 self.variant(CC2LOC_A::LOC7)
428 }
429}
430#[doc = "Field `CC3LOC` reader - I/O Location"]
431pub type CC3LOC_R = crate::FieldReader<u8, CC3LOC_A>;
432#[doc = "I/O Location\n\nValue on reset: 0"]
433#[derive(Clone, Copy, Debug, PartialEq, Eq)]
434#[repr(u8)]
435pub enum CC3LOC_A {
436 #[doc = "0: Location 0"]
437 LOC0 = 0,
438 #[doc = "1: Location 1"]
439 LOC1 = 1,
440 #[doc = "2: Location 2"]
441 LOC2 = 2,
442 #[doc = "3: Location 3"]
443 LOC3 = 3,
444 #[doc = "4: Location 4"]
445 LOC4 = 4,
446 #[doc = "5: Location 5"]
447 LOC5 = 5,
448 #[doc = "6: Location 6"]
449 LOC6 = 6,
450}
451impl From<CC3LOC_A> for u8 {
452 #[inline(always)]
453 fn from(variant: CC3LOC_A) -> Self {
454 variant as _
455 }
456}
457impl CC3LOC_R {
458 #[doc = "Get enumerated values variant"]
459 #[inline(always)]
460 pub fn variant(&self) -> Option<CC3LOC_A> {
461 match self.bits {
462 0 => Some(CC3LOC_A::LOC0),
463 1 => Some(CC3LOC_A::LOC1),
464 2 => Some(CC3LOC_A::LOC2),
465 3 => Some(CC3LOC_A::LOC3),
466 4 => Some(CC3LOC_A::LOC4),
467 5 => Some(CC3LOC_A::LOC5),
468 6 => Some(CC3LOC_A::LOC6),
469 _ => None,
470 }
471 }
472 #[doc = "Checks if the value of the field is `LOC0`"]
473 #[inline(always)]
474 pub fn is_loc0(&self) -> bool {
475 *self == CC3LOC_A::LOC0
476 }
477 #[doc = "Checks if the value of the field is `LOC1`"]
478 #[inline(always)]
479 pub fn is_loc1(&self) -> bool {
480 *self == CC3LOC_A::LOC1
481 }
482 #[doc = "Checks if the value of the field is `LOC2`"]
483 #[inline(always)]
484 pub fn is_loc2(&self) -> bool {
485 *self == CC3LOC_A::LOC2
486 }
487 #[doc = "Checks if the value of the field is `LOC3`"]
488 #[inline(always)]
489 pub fn is_loc3(&self) -> bool {
490 *self == CC3LOC_A::LOC3
491 }
492 #[doc = "Checks if the value of the field is `LOC4`"]
493 #[inline(always)]
494 pub fn is_loc4(&self) -> bool {
495 *self == CC3LOC_A::LOC4
496 }
497 #[doc = "Checks if the value of the field is `LOC5`"]
498 #[inline(always)]
499 pub fn is_loc5(&self) -> bool {
500 *self == CC3LOC_A::LOC5
501 }
502 #[doc = "Checks if the value of the field is `LOC6`"]
503 #[inline(always)]
504 pub fn is_loc6(&self) -> bool {
505 *self == CC3LOC_A::LOC6
506 }
507}
508#[doc = "Field `CC3LOC` writer - I/O Location"]
509pub type CC3LOC_W<'a, const O: u8> =
510 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CC3LOC_A, 6, O>;
511impl<'a, const O: u8> CC3LOC_W<'a, O> {
512 #[doc = "Location 0"]
513 #[inline(always)]
514 pub fn loc0(self) -> &'a mut W {
515 self.variant(CC3LOC_A::LOC0)
516 }
517 #[doc = "Location 1"]
518 #[inline(always)]
519 pub fn loc1(self) -> &'a mut W {
520 self.variant(CC3LOC_A::LOC1)
521 }
522 #[doc = "Location 2"]
523 #[inline(always)]
524 pub fn loc2(self) -> &'a mut W {
525 self.variant(CC3LOC_A::LOC2)
526 }
527 #[doc = "Location 3"]
528 #[inline(always)]
529 pub fn loc3(self) -> &'a mut W {
530 self.variant(CC3LOC_A::LOC3)
531 }
532 #[doc = "Location 4"]
533 #[inline(always)]
534 pub fn loc4(self) -> &'a mut W {
535 self.variant(CC3LOC_A::LOC4)
536 }
537 #[doc = "Location 5"]
538 #[inline(always)]
539 pub fn loc5(self) -> &'a mut W {
540 self.variant(CC3LOC_A::LOC5)
541 }
542 #[doc = "Location 6"]
543 #[inline(always)]
544 pub fn loc6(self) -> &'a mut W {
545 self.variant(CC3LOC_A::LOC6)
546 }
547}
548impl R {
549 #[doc = "Bits 0:5 - I/O Location"]
550 #[inline(always)]
551 pub fn cc0loc(&self) -> CC0LOC_R {
552 CC0LOC_R::new((self.bits & 0x3f) as u8)
553 }
554 #[doc = "Bits 8:13 - I/O Location"]
555 #[inline(always)]
556 pub fn cc1loc(&self) -> CC1LOC_R {
557 CC1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
558 }
559 #[doc = "Bits 16:21 - I/O Location"]
560 #[inline(always)]
561 pub fn cc2loc(&self) -> CC2LOC_R {
562 CC2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
563 }
564 #[doc = "Bits 24:29 - I/O Location"]
565 #[inline(always)]
566 pub fn cc3loc(&self) -> CC3LOC_R {
567 CC3LOC_R::new(((self.bits >> 24) & 0x3f) as u8)
568 }
569}
570impl W {
571 #[doc = "Bits 0:5 - I/O Location"]
572 #[inline(always)]
573 #[must_use]
574 pub fn cc0loc(&mut self) -> CC0LOC_W<0> {
575 CC0LOC_W::new(self)
576 }
577 #[doc = "Bits 8:13 - I/O Location"]
578 #[inline(always)]
579 #[must_use]
580 pub fn cc1loc(&mut self) -> CC1LOC_W<8> {
581 CC1LOC_W::new(self)
582 }
583 #[doc = "Bits 16:21 - I/O Location"]
584 #[inline(always)]
585 #[must_use]
586 pub fn cc2loc(&mut self) -> CC2LOC_W<16> {
587 CC2LOC_W::new(self)
588 }
589 #[doc = "Bits 24:29 - I/O Location"]
590 #[inline(always)]
591 #[must_use]
592 pub fn cc3loc(&mut self) -> CC3LOC_W<24> {
593 CC3LOC_W::new(self)
594 }
595 #[doc = "Writes raw bits to the register."]
596 #[inline(always)]
597 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
598 self.0.bits(bits);
599 self
600 }
601}
602#[doc = "I/O Routing Location Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [routeloc0](index.html) module"]
603pub struct ROUTELOC0_SPEC;
604impl crate::RegisterSpec for ROUTELOC0_SPEC {
605 type Ux = u32;
606}
607#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
608impl crate::Readable for ROUTELOC0_SPEC {
609 type Reader = R;
610}
611#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
612impl crate::Writable for ROUTELOC0_SPEC {
613 type Writer = W;
614 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
615 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
616}
617#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
618impl crate::Resettable for ROUTELOC0_SPEC {
619 const RESET_VALUE: Self::Ux = 0;
620}