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 = "Field `RXLOC` reader - I/O Location"]
38pub type RXLOC_R = crate::FieldReader<u8, RXLOC_A>;
39#[doc = "I/O Location\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum RXLOC_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 #[doc = "8: Location 8"]
60 LOC8 = 8,
61 #[doc = "9: Location 9"]
62 LOC9 = 9,
63 #[doc = "10: Location 10"]
64 LOC10 = 10,
65 #[doc = "11: Location 11"]
66 LOC11 = 11,
67 #[doc = "12: Location 12"]
68 LOC12 = 12,
69 #[doc = "13: Location 13"]
70 LOC13 = 13,
71 #[doc = "14: Location 14"]
72 LOC14 = 14,
73 #[doc = "15: Location 15"]
74 LOC15 = 15,
75 #[doc = "16: Location 16"]
76 LOC16 = 16,
77 #[doc = "17: Location 17"]
78 LOC17 = 17,
79 #[doc = "18: Location 18"]
80 LOC18 = 18,
81 #[doc = "19: Location 19"]
82 LOC19 = 19,
83 #[doc = "20: Location 20"]
84 LOC20 = 20,
85 #[doc = "21: Location 21"]
86 LOC21 = 21,
87 #[doc = "22: Location 22"]
88 LOC22 = 22,
89 #[doc = "23: Location 23"]
90 LOC23 = 23,
91 #[doc = "24: Location 24"]
92 LOC24 = 24,
93 #[doc = "25: Location 25"]
94 LOC25 = 25,
95 #[doc = "26: Location 26"]
96 LOC26 = 26,
97 #[doc = "27: Location 27"]
98 LOC27 = 27,
99 #[doc = "28: Location 28"]
100 LOC28 = 28,
101 #[doc = "29: Location 29"]
102 LOC29 = 29,
103 #[doc = "30: Location 30"]
104 LOC30 = 30,
105 #[doc = "31: Location 31"]
106 LOC31 = 31,
107}
108impl From<RXLOC_A> for u8 {
109 #[inline(always)]
110 fn from(variant: RXLOC_A) -> Self {
111 variant as _
112 }
113}
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, const O: u8> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, RXLOC_A, 6, O>;
317impl<'a, const O: u8> RXLOC_W<'a, O> {
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 = "Field `TXLOC` reader - I/O Location"]
480pub type TXLOC_R = crate::FieldReader<u8, TXLOC_A>;
481#[doc = "I/O Location\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq, Eq)]
483#[repr(u8)]
484pub enum TXLOC_A {
485 #[doc = "0: Location 0"]
486 LOC0 = 0,
487 #[doc = "1: Location 1"]
488 LOC1 = 1,
489 #[doc = "2: Location 2"]
490 LOC2 = 2,
491 #[doc = "3: Location 3"]
492 LOC3 = 3,
493 #[doc = "4: Location 4"]
494 LOC4 = 4,
495 #[doc = "5: Location 5"]
496 LOC5 = 5,
497 #[doc = "6: Location 6"]
498 LOC6 = 6,
499 #[doc = "7: Location 7"]
500 LOC7 = 7,
501 #[doc = "8: Location 8"]
502 LOC8 = 8,
503 #[doc = "9: Location 9"]
504 LOC9 = 9,
505 #[doc = "10: Location 10"]
506 LOC10 = 10,
507 #[doc = "11: Location 11"]
508 LOC11 = 11,
509 #[doc = "12: Location 12"]
510 LOC12 = 12,
511 #[doc = "13: Location 13"]
512 LOC13 = 13,
513 #[doc = "14: Location 14"]
514 LOC14 = 14,
515 #[doc = "15: Location 15"]
516 LOC15 = 15,
517 #[doc = "16: Location 16"]
518 LOC16 = 16,
519 #[doc = "17: Location 17"]
520 LOC17 = 17,
521 #[doc = "18: Location 18"]
522 LOC18 = 18,
523 #[doc = "19: Location 19"]
524 LOC19 = 19,
525 #[doc = "20: Location 20"]
526 LOC20 = 20,
527 #[doc = "21: Location 21"]
528 LOC21 = 21,
529 #[doc = "22: Location 22"]
530 LOC22 = 22,
531 #[doc = "23: Location 23"]
532 LOC23 = 23,
533 #[doc = "24: Location 24"]
534 LOC24 = 24,
535 #[doc = "25: Location 25"]
536 LOC25 = 25,
537 #[doc = "26: Location 26"]
538 LOC26 = 26,
539 #[doc = "27: Location 27"]
540 LOC27 = 27,
541 #[doc = "28: Location 28"]
542 LOC28 = 28,
543 #[doc = "29: Location 29"]
544 LOC29 = 29,
545 #[doc = "30: Location 30"]
546 LOC30 = 30,
547 #[doc = "31: Location 31"]
548 LOC31 = 31,
549}
550impl From<TXLOC_A> for u8 {
551 #[inline(always)]
552 fn from(variant: TXLOC_A) -> Self {
553 variant as _
554 }
555}
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, const O: u8> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, TXLOC_A, 6, O>;
759impl<'a, const O: u8> TXLOC_W<'a, O> {
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 = "Field `CSLOC` reader - I/O Location"]
922pub type CSLOC_R = crate::FieldReader<u8, CSLOC_A>;
923#[doc = "I/O Location\n\nValue on reset: 0"]
924#[derive(Clone, Copy, Debug, PartialEq, Eq)]
925#[repr(u8)]
926pub enum CSLOC_A {
927 #[doc = "0: Location 0"]
928 LOC0 = 0,
929 #[doc = "1: Location 1"]
930 LOC1 = 1,
931 #[doc = "2: Location 2"]
932 LOC2 = 2,
933 #[doc = "3: Location 3"]
934 LOC3 = 3,
935 #[doc = "4: Location 4"]
936 LOC4 = 4,
937 #[doc = "5: Location 5"]
938 LOC5 = 5,
939 #[doc = "6: Location 6"]
940 LOC6 = 6,
941 #[doc = "7: Location 7"]
942 LOC7 = 7,
943 #[doc = "8: Location 8"]
944 LOC8 = 8,
945 #[doc = "9: Location 9"]
946 LOC9 = 9,
947 #[doc = "10: Location 10"]
948 LOC10 = 10,
949 #[doc = "11: Location 11"]
950 LOC11 = 11,
951 #[doc = "12: Location 12"]
952 LOC12 = 12,
953 #[doc = "13: Location 13"]
954 LOC13 = 13,
955 #[doc = "14: Location 14"]
956 LOC14 = 14,
957 #[doc = "15: Location 15"]
958 LOC15 = 15,
959 #[doc = "16: Location 16"]
960 LOC16 = 16,
961 #[doc = "17: Location 17"]
962 LOC17 = 17,
963 #[doc = "18: Location 18"]
964 LOC18 = 18,
965 #[doc = "19: Location 19"]
966 LOC19 = 19,
967 #[doc = "20: Location 20"]
968 LOC20 = 20,
969 #[doc = "21: Location 21"]
970 LOC21 = 21,
971 #[doc = "22: Location 22"]
972 LOC22 = 22,
973 #[doc = "23: Location 23"]
974 LOC23 = 23,
975 #[doc = "24: Location 24"]
976 LOC24 = 24,
977 #[doc = "25: Location 25"]
978 LOC25 = 25,
979 #[doc = "26: Location 26"]
980 LOC26 = 26,
981 #[doc = "27: Location 27"]
982 LOC27 = 27,
983 #[doc = "28: Location 28"]
984 LOC28 = 28,
985 #[doc = "29: Location 29"]
986 LOC29 = 29,
987 #[doc = "30: Location 30"]
988 LOC30 = 30,
989 #[doc = "31: Location 31"]
990 LOC31 = 31,
991}
992impl From<CSLOC_A> for u8 {
993 #[inline(always)]
994 fn from(variant: CSLOC_A) -> Self {
995 variant as _
996 }
997}
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, const O: u8> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CSLOC_A, 6, O>;
1201impl<'a, const O: u8> CSLOC_W<'a, O> {
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 = "Field `CLKLOC` reader - I/O Location"]
1364pub type CLKLOC_R = crate::FieldReader<u8, CLKLOC_A>;
1365#[doc = "I/O Location\n\nValue on reset: 0"]
1366#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1367#[repr(u8)]
1368pub enum CLKLOC_A {
1369 #[doc = "0: Location 0"]
1370 LOC0 = 0,
1371 #[doc = "1: Location 1"]
1372 LOC1 = 1,
1373 #[doc = "2: Location 2"]
1374 LOC2 = 2,
1375 #[doc = "3: Location 3"]
1376 LOC3 = 3,
1377 #[doc = "4: Location 4"]
1378 LOC4 = 4,
1379 #[doc = "5: Location 5"]
1380 LOC5 = 5,
1381 #[doc = "6: Location 6"]
1382 LOC6 = 6,
1383 #[doc = "7: Location 7"]
1384 LOC7 = 7,
1385 #[doc = "8: Location 8"]
1386 LOC8 = 8,
1387 #[doc = "9: Location 9"]
1388 LOC9 = 9,
1389 #[doc = "10: Location 10"]
1390 LOC10 = 10,
1391 #[doc = "11: Location 11"]
1392 LOC11 = 11,
1393 #[doc = "12: Location 12"]
1394 LOC12 = 12,
1395 #[doc = "13: Location 13"]
1396 LOC13 = 13,
1397 #[doc = "14: Location 14"]
1398 LOC14 = 14,
1399 #[doc = "15: Location 15"]
1400 LOC15 = 15,
1401 #[doc = "16: Location 16"]
1402 LOC16 = 16,
1403 #[doc = "17: Location 17"]
1404 LOC17 = 17,
1405 #[doc = "18: Location 18"]
1406 LOC18 = 18,
1407 #[doc = "19: Location 19"]
1408 LOC19 = 19,
1409 #[doc = "20: Location 20"]
1410 LOC20 = 20,
1411 #[doc = "21: Location 21"]
1412 LOC21 = 21,
1413 #[doc = "22: Location 22"]
1414 LOC22 = 22,
1415 #[doc = "23: Location 23"]
1416 LOC23 = 23,
1417 #[doc = "24: Location 24"]
1418 LOC24 = 24,
1419 #[doc = "25: Location 25"]
1420 LOC25 = 25,
1421 #[doc = "26: Location 26"]
1422 LOC26 = 26,
1423 #[doc = "27: Location 27"]
1424 LOC27 = 27,
1425 #[doc = "28: Location 28"]
1426 LOC28 = 28,
1427 #[doc = "29: Location 29"]
1428 LOC29 = 29,
1429 #[doc = "30: Location 30"]
1430 LOC30 = 30,
1431 #[doc = "31: Location 31"]
1432 LOC31 = 31,
1433}
1434impl From<CLKLOC_A> for u8 {
1435 #[inline(always)]
1436 fn from(variant: CLKLOC_A) -> Self {
1437 variant as _
1438 }
1439}
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, const O: u8> =
1643 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CLKLOC_A, 6, O>;
1644impl<'a, const O: u8> CLKLOC_W<'a, O> {
1645 #[doc = "Location 0"]
1646 #[inline(always)]
1647 pub fn loc0(self) -> &'a mut W {
1648 self.variant(CLKLOC_A::LOC0)
1649 }
1650 #[doc = "Location 1"]
1651 #[inline(always)]
1652 pub fn loc1(self) -> &'a mut W {
1653 self.variant(CLKLOC_A::LOC1)
1654 }
1655 #[doc = "Location 2"]
1656 #[inline(always)]
1657 pub fn loc2(self) -> &'a mut W {
1658 self.variant(CLKLOC_A::LOC2)
1659 }
1660 #[doc = "Location 3"]
1661 #[inline(always)]
1662 pub fn loc3(self) -> &'a mut W {
1663 self.variant(CLKLOC_A::LOC3)
1664 }
1665 #[doc = "Location 4"]
1666 #[inline(always)]
1667 pub fn loc4(self) -> &'a mut W {
1668 self.variant(CLKLOC_A::LOC4)
1669 }
1670 #[doc = "Location 5"]
1671 #[inline(always)]
1672 pub fn loc5(self) -> &'a mut W {
1673 self.variant(CLKLOC_A::LOC5)
1674 }
1675 #[doc = "Location 6"]
1676 #[inline(always)]
1677 pub fn loc6(self) -> &'a mut W {
1678 self.variant(CLKLOC_A::LOC6)
1679 }
1680 #[doc = "Location 7"]
1681 #[inline(always)]
1682 pub fn loc7(self) -> &'a mut W {
1683 self.variant(CLKLOC_A::LOC7)
1684 }
1685 #[doc = "Location 8"]
1686 #[inline(always)]
1687 pub fn loc8(self) -> &'a mut W {
1688 self.variant(CLKLOC_A::LOC8)
1689 }
1690 #[doc = "Location 9"]
1691 #[inline(always)]
1692 pub fn loc9(self) -> &'a mut W {
1693 self.variant(CLKLOC_A::LOC9)
1694 }
1695 #[doc = "Location 10"]
1696 #[inline(always)]
1697 pub fn loc10(self) -> &'a mut W {
1698 self.variant(CLKLOC_A::LOC10)
1699 }
1700 #[doc = "Location 11"]
1701 #[inline(always)]
1702 pub fn loc11(self) -> &'a mut W {
1703 self.variant(CLKLOC_A::LOC11)
1704 }
1705 #[doc = "Location 12"]
1706 #[inline(always)]
1707 pub fn loc12(self) -> &'a mut W {
1708 self.variant(CLKLOC_A::LOC12)
1709 }
1710 #[doc = "Location 13"]
1711 #[inline(always)]
1712 pub fn loc13(self) -> &'a mut W {
1713 self.variant(CLKLOC_A::LOC13)
1714 }
1715 #[doc = "Location 14"]
1716 #[inline(always)]
1717 pub fn loc14(self) -> &'a mut W {
1718 self.variant(CLKLOC_A::LOC14)
1719 }
1720 #[doc = "Location 15"]
1721 #[inline(always)]
1722 pub fn loc15(self) -> &'a mut W {
1723 self.variant(CLKLOC_A::LOC15)
1724 }
1725 #[doc = "Location 16"]
1726 #[inline(always)]
1727 pub fn loc16(self) -> &'a mut W {
1728 self.variant(CLKLOC_A::LOC16)
1729 }
1730 #[doc = "Location 17"]
1731 #[inline(always)]
1732 pub fn loc17(self) -> &'a mut W {
1733 self.variant(CLKLOC_A::LOC17)
1734 }
1735 #[doc = "Location 18"]
1736 #[inline(always)]
1737 pub fn loc18(self) -> &'a mut W {
1738 self.variant(CLKLOC_A::LOC18)
1739 }
1740 #[doc = "Location 19"]
1741 #[inline(always)]
1742 pub fn loc19(self) -> &'a mut W {
1743 self.variant(CLKLOC_A::LOC19)
1744 }
1745 #[doc = "Location 20"]
1746 #[inline(always)]
1747 pub fn loc20(self) -> &'a mut W {
1748 self.variant(CLKLOC_A::LOC20)
1749 }
1750 #[doc = "Location 21"]
1751 #[inline(always)]
1752 pub fn loc21(self) -> &'a mut W {
1753 self.variant(CLKLOC_A::LOC21)
1754 }
1755 #[doc = "Location 22"]
1756 #[inline(always)]
1757 pub fn loc22(self) -> &'a mut W {
1758 self.variant(CLKLOC_A::LOC22)
1759 }
1760 #[doc = "Location 23"]
1761 #[inline(always)]
1762 pub fn loc23(self) -> &'a mut W {
1763 self.variant(CLKLOC_A::LOC23)
1764 }
1765 #[doc = "Location 24"]
1766 #[inline(always)]
1767 pub fn loc24(self) -> &'a mut W {
1768 self.variant(CLKLOC_A::LOC24)
1769 }
1770 #[doc = "Location 25"]
1771 #[inline(always)]
1772 pub fn loc25(self) -> &'a mut W {
1773 self.variant(CLKLOC_A::LOC25)
1774 }
1775 #[doc = "Location 26"]
1776 #[inline(always)]
1777 pub fn loc26(self) -> &'a mut W {
1778 self.variant(CLKLOC_A::LOC26)
1779 }
1780 #[doc = "Location 27"]
1781 #[inline(always)]
1782 pub fn loc27(self) -> &'a mut W {
1783 self.variant(CLKLOC_A::LOC27)
1784 }
1785 #[doc = "Location 28"]
1786 #[inline(always)]
1787 pub fn loc28(self) -> &'a mut W {
1788 self.variant(CLKLOC_A::LOC28)
1789 }
1790 #[doc = "Location 29"]
1791 #[inline(always)]
1792 pub fn loc29(self) -> &'a mut W {
1793 self.variant(CLKLOC_A::LOC29)
1794 }
1795 #[doc = "Location 30"]
1796 #[inline(always)]
1797 pub fn loc30(self) -> &'a mut W {
1798 self.variant(CLKLOC_A::LOC30)
1799 }
1800 #[doc = "Location 31"]
1801 #[inline(always)]
1802 pub fn loc31(self) -> &'a mut W {
1803 self.variant(CLKLOC_A::LOC31)
1804 }
1805}
1806impl R {
1807 #[doc = "Bits 0:5 - I/O Location"]
1808 #[inline(always)]
1809 pub fn rxloc(&self) -> RXLOC_R {
1810 RXLOC_R::new((self.bits & 0x3f) as u8)
1811 }
1812 #[doc = "Bits 8:13 - I/O Location"]
1813 #[inline(always)]
1814 pub fn txloc(&self) -> TXLOC_R {
1815 TXLOC_R::new(((self.bits >> 8) & 0x3f) as u8)
1816 }
1817 #[doc = "Bits 16:21 - I/O Location"]
1818 #[inline(always)]
1819 pub fn csloc(&self) -> CSLOC_R {
1820 CSLOC_R::new(((self.bits >> 16) & 0x3f) as u8)
1821 }
1822 #[doc = "Bits 24:29 - I/O Location"]
1823 #[inline(always)]
1824 pub fn clkloc(&self) -> CLKLOC_R {
1825 CLKLOC_R::new(((self.bits >> 24) & 0x3f) as u8)
1826 }
1827}
1828impl W {
1829 #[doc = "Bits 0:5 - I/O Location"]
1830 #[inline(always)]
1831 #[must_use]
1832 pub fn rxloc(&mut self) -> RXLOC_W<0> {
1833 RXLOC_W::new(self)
1834 }
1835 #[doc = "Bits 8:13 - I/O Location"]
1836 #[inline(always)]
1837 #[must_use]
1838 pub fn txloc(&mut self) -> TXLOC_W<8> {
1839 TXLOC_W::new(self)
1840 }
1841 #[doc = "Bits 16:21 - I/O Location"]
1842 #[inline(always)]
1843 #[must_use]
1844 pub fn csloc(&mut self) -> CSLOC_W<16> {
1845 CSLOC_W::new(self)
1846 }
1847 #[doc = "Bits 24:29 - I/O Location"]
1848 #[inline(always)]
1849 #[must_use]
1850 pub fn clkloc(&mut self) -> CLKLOC_W<24> {
1851 CLKLOC_W::new(self)
1852 }
1853 #[doc = "Writes raw bits to the register."]
1854 #[inline(always)]
1855 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1856 self.0.bits(bits);
1857 self
1858 }
1859}
1860#[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"]
1861pub struct ROUTELOC0_SPEC;
1862impl crate::RegisterSpec for ROUTELOC0_SPEC {
1863 type Ux = u32;
1864}
1865#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
1866impl crate::Readable for ROUTELOC0_SPEC {
1867 type Reader = R;
1868}
1869#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
1870impl crate::Writable for ROUTELOC0_SPEC {
1871 type Writer = W;
1872 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1873 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1874}
1875#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
1876impl crate::Resettable for ROUTELOC0_SPEC {
1877 const RESET_VALUE: Self::Ux = 0;
1878}