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