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 CH0LOC_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}
70impl From<CH0LOC_A> for u8 {
71 #[inline(always)]
72 fn from(variant: CH0LOC_A) -> Self {
73 variant as _
74 }
75}
76#[doc = "Field `CH0LOC` reader - I/O Location"]
77pub type CH0LOC_R = crate::FieldReader<u8, CH0LOC_A>;
78impl CH0LOC_R {
79 #[doc = "Get enumerated values variant"]
80 #[inline(always)]
81 pub fn variant(&self) -> Option<CH0LOC_A> {
82 match self.bits {
83 0 => Some(CH0LOC_A::LOC0),
84 1 => Some(CH0LOC_A::LOC1),
85 2 => Some(CH0LOC_A::LOC2),
86 3 => Some(CH0LOC_A::LOC3),
87 4 => Some(CH0LOC_A::LOC4),
88 5 => Some(CH0LOC_A::LOC5),
89 6 => Some(CH0LOC_A::LOC6),
90 7 => Some(CH0LOC_A::LOC7),
91 8 => Some(CH0LOC_A::LOC8),
92 9 => Some(CH0LOC_A::LOC9),
93 10 => Some(CH0LOC_A::LOC10),
94 11 => Some(CH0LOC_A::LOC11),
95 12 => Some(CH0LOC_A::LOC12),
96 13 => Some(CH0LOC_A::LOC13),
97 _ => None,
98 }
99 }
100 #[doc = "Checks if the value of the field is `LOC0`"]
101 #[inline(always)]
102 pub fn is_loc0(&self) -> bool {
103 *self == CH0LOC_A::LOC0
104 }
105 #[doc = "Checks if the value of the field is `LOC1`"]
106 #[inline(always)]
107 pub fn is_loc1(&self) -> bool {
108 *self == CH0LOC_A::LOC1
109 }
110 #[doc = "Checks if the value of the field is `LOC2`"]
111 #[inline(always)]
112 pub fn is_loc2(&self) -> bool {
113 *self == CH0LOC_A::LOC2
114 }
115 #[doc = "Checks if the value of the field is `LOC3`"]
116 #[inline(always)]
117 pub fn is_loc3(&self) -> bool {
118 *self == CH0LOC_A::LOC3
119 }
120 #[doc = "Checks if the value of the field is `LOC4`"]
121 #[inline(always)]
122 pub fn is_loc4(&self) -> bool {
123 *self == CH0LOC_A::LOC4
124 }
125 #[doc = "Checks if the value of the field is `LOC5`"]
126 #[inline(always)]
127 pub fn is_loc5(&self) -> bool {
128 *self == CH0LOC_A::LOC5
129 }
130 #[doc = "Checks if the value of the field is `LOC6`"]
131 #[inline(always)]
132 pub fn is_loc6(&self) -> bool {
133 *self == CH0LOC_A::LOC6
134 }
135 #[doc = "Checks if the value of the field is `LOC7`"]
136 #[inline(always)]
137 pub fn is_loc7(&self) -> bool {
138 *self == CH0LOC_A::LOC7
139 }
140 #[doc = "Checks if the value of the field is `LOC8`"]
141 #[inline(always)]
142 pub fn is_loc8(&self) -> bool {
143 *self == CH0LOC_A::LOC8
144 }
145 #[doc = "Checks if the value of the field is `LOC9`"]
146 #[inline(always)]
147 pub fn is_loc9(&self) -> bool {
148 *self == CH0LOC_A::LOC9
149 }
150 #[doc = "Checks if the value of the field is `LOC10`"]
151 #[inline(always)]
152 pub fn is_loc10(&self) -> bool {
153 *self == CH0LOC_A::LOC10
154 }
155 #[doc = "Checks if the value of the field is `LOC11`"]
156 #[inline(always)]
157 pub fn is_loc11(&self) -> bool {
158 *self == CH0LOC_A::LOC11
159 }
160 #[doc = "Checks if the value of the field is `LOC12`"]
161 #[inline(always)]
162 pub fn is_loc12(&self) -> bool {
163 *self == CH0LOC_A::LOC12
164 }
165 #[doc = "Checks if the value of the field is `LOC13`"]
166 #[inline(always)]
167 pub fn is_loc13(&self) -> bool {
168 *self == CH0LOC_A::LOC13
169 }
170}
171#[doc = "Field `CH0LOC` writer - I/O Location"]
172pub type CH0LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CH0LOC_A, 6, 0>;
173impl<'a> CH0LOC_W<'a> {
174 #[doc = "Location 0"]
175 #[inline(always)]
176 pub fn loc0(self) -> &'a mut W {
177 self.variant(CH0LOC_A::LOC0)
178 }
179 #[doc = "Location 1"]
180 #[inline(always)]
181 pub fn loc1(self) -> &'a mut W {
182 self.variant(CH0LOC_A::LOC1)
183 }
184 #[doc = "Location 2"]
185 #[inline(always)]
186 pub fn loc2(self) -> &'a mut W {
187 self.variant(CH0LOC_A::LOC2)
188 }
189 #[doc = "Location 3"]
190 #[inline(always)]
191 pub fn loc3(self) -> &'a mut W {
192 self.variant(CH0LOC_A::LOC3)
193 }
194 #[doc = "Location 4"]
195 #[inline(always)]
196 pub fn loc4(self) -> &'a mut W {
197 self.variant(CH0LOC_A::LOC4)
198 }
199 #[doc = "Location 5"]
200 #[inline(always)]
201 pub fn loc5(self) -> &'a mut W {
202 self.variant(CH0LOC_A::LOC5)
203 }
204 #[doc = "Location 6"]
205 #[inline(always)]
206 pub fn loc6(self) -> &'a mut W {
207 self.variant(CH0LOC_A::LOC6)
208 }
209 #[doc = "Location 7"]
210 #[inline(always)]
211 pub fn loc7(self) -> &'a mut W {
212 self.variant(CH0LOC_A::LOC7)
213 }
214 #[doc = "Location 8"]
215 #[inline(always)]
216 pub fn loc8(self) -> &'a mut W {
217 self.variant(CH0LOC_A::LOC8)
218 }
219 #[doc = "Location 9"]
220 #[inline(always)]
221 pub fn loc9(self) -> &'a mut W {
222 self.variant(CH0LOC_A::LOC9)
223 }
224 #[doc = "Location 10"]
225 #[inline(always)]
226 pub fn loc10(self) -> &'a mut W {
227 self.variant(CH0LOC_A::LOC10)
228 }
229 #[doc = "Location 11"]
230 #[inline(always)]
231 pub fn loc11(self) -> &'a mut W {
232 self.variant(CH0LOC_A::LOC11)
233 }
234 #[doc = "Location 12"]
235 #[inline(always)]
236 pub fn loc12(self) -> &'a mut W {
237 self.variant(CH0LOC_A::LOC12)
238 }
239 #[doc = "Location 13"]
240 #[inline(always)]
241 pub fn loc13(self) -> &'a mut W {
242 self.variant(CH0LOC_A::LOC13)
243 }
244}
245#[doc = "I/O Location\n\nValue on reset: 0"]
246#[derive(Clone, Copy, Debug, PartialEq)]
247#[repr(u8)]
248pub enum CH1LOC_A {
249 #[doc = "0: Location 0"]
250 LOC0 = 0,
251 #[doc = "1: Location 1"]
252 LOC1 = 1,
253 #[doc = "2: Location 2"]
254 LOC2 = 2,
255 #[doc = "3: Location 3"]
256 LOC3 = 3,
257 #[doc = "4: Location 4"]
258 LOC4 = 4,
259 #[doc = "5: Location 5"]
260 LOC5 = 5,
261 #[doc = "6: Location 6"]
262 LOC6 = 6,
263 #[doc = "7: Location 7"]
264 LOC7 = 7,
265}
266impl From<CH1LOC_A> for u8 {
267 #[inline(always)]
268 fn from(variant: CH1LOC_A) -> Self {
269 variant as _
270 }
271}
272#[doc = "Field `CH1LOC` reader - I/O Location"]
273pub type CH1LOC_R = crate::FieldReader<u8, CH1LOC_A>;
274impl CH1LOC_R {
275 #[doc = "Get enumerated values variant"]
276 #[inline(always)]
277 pub fn variant(&self) -> Option<CH1LOC_A> {
278 match self.bits {
279 0 => Some(CH1LOC_A::LOC0),
280 1 => Some(CH1LOC_A::LOC1),
281 2 => Some(CH1LOC_A::LOC2),
282 3 => Some(CH1LOC_A::LOC3),
283 4 => Some(CH1LOC_A::LOC4),
284 5 => Some(CH1LOC_A::LOC5),
285 6 => Some(CH1LOC_A::LOC6),
286 7 => Some(CH1LOC_A::LOC7),
287 _ => None,
288 }
289 }
290 #[doc = "Checks if the value of the field is `LOC0`"]
291 #[inline(always)]
292 pub fn is_loc0(&self) -> bool {
293 *self == CH1LOC_A::LOC0
294 }
295 #[doc = "Checks if the value of the field is `LOC1`"]
296 #[inline(always)]
297 pub fn is_loc1(&self) -> bool {
298 *self == CH1LOC_A::LOC1
299 }
300 #[doc = "Checks if the value of the field is `LOC2`"]
301 #[inline(always)]
302 pub fn is_loc2(&self) -> bool {
303 *self == CH1LOC_A::LOC2
304 }
305 #[doc = "Checks if the value of the field is `LOC3`"]
306 #[inline(always)]
307 pub fn is_loc3(&self) -> bool {
308 *self == CH1LOC_A::LOC3
309 }
310 #[doc = "Checks if the value of the field is `LOC4`"]
311 #[inline(always)]
312 pub fn is_loc4(&self) -> bool {
313 *self == CH1LOC_A::LOC4
314 }
315 #[doc = "Checks if the value of the field is `LOC5`"]
316 #[inline(always)]
317 pub fn is_loc5(&self) -> bool {
318 *self == CH1LOC_A::LOC5
319 }
320 #[doc = "Checks if the value of the field is `LOC6`"]
321 #[inline(always)]
322 pub fn is_loc6(&self) -> bool {
323 *self == CH1LOC_A::LOC6
324 }
325 #[doc = "Checks if the value of the field is `LOC7`"]
326 #[inline(always)]
327 pub fn is_loc7(&self) -> bool {
328 *self == CH1LOC_A::LOC7
329 }
330}
331#[doc = "Field `CH1LOC` writer - I/O Location"]
332pub type CH1LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CH1LOC_A, 6, 8>;
333impl<'a> CH1LOC_W<'a> {
334 #[doc = "Location 0"]
335 #[inline(always)]
336 pub fn loc0(self) -> &'a mut W {
337 self.variant(CH1LOC_A::LOC0)
338 }
339 #[doc = "Location 1"]
340 #[inline(always)]
341 pub fn loc1(self) -> &'a mut W {
342 self.variant(CH1LOC_A::LOC1)
343 }
344 #[doc = "Location 2"]
345 #[inline(always)]
346 pub fn loc2(self) -> &'a mut W {
347 self.variant(CH1LOC_A::LOC2)
348 }
349 #[doc = "Location 3"]
350 #[inline(always)]
351 pub fn loc3(self) -> &'a mut W {
352 self.variant(CH1LOC_A::LOC3)
353 }
354 #[doc = "Location 4"]
355 #[inline(always)]
356 pub fn loc4(self) -> &'a mut W {
357 self.variant(CH1LOC_A::LOC4)
358 }
359 #[doc = "Location 5"]
360 #[inline(always)]
361 pub fn loc5(self) -> &'a mut W {
362 self.variant(CH1LOC_A::LOC5)
363 }
364 #[doc = "Location 6"]
365 #[inline(always)]
366 pub fn loc6(self) -> &'a mut W {
367 self.variant(CH1LOC_A::LOC6)
368 }
369 #[doc = "Location 7"]
370 #[inline(always)]
371 pub fn loc7(self) -> &'a mut W {
372 self.variant(CH1LOC_A::LOC7)
373 }
374}
375#[doc = "I/O Location\n\nValue on reset: 0"]
376#[derive(Clone, Copy, Debug, PartialEq)]
377#[repr(u8)]
378pub enum CH2LOC_A {
379 #[doc = "0: Location 0"]
380 LOC0 = 0,
381 #[doc = "1: Location 1"]
382 LOC1 = 1,
383 #[doc = "2: Location 2"]
384 LOC2 = 2,
385 #[doc = "3: Location 3"]
386 LOC3 = 3,
387 #[doc = "4: Location 4"]
388 LOC4 = 4,
389 #[doc = "5: Location 5"]
390 LOC5 = 5,
391 #[doc = "6: Location 6"]
392 LOC6 = 6,
393 #[doc = "7: Location 7"]
394 LOC7 = 7,
395}
396impl From<CH2LOC_A> for u8 {
397 #[inline(always)]
398 fn from(variant: CH2LOC_A) -> Self {
399 variant as _
400 }
401}
402#[doc = "Field `CH2LOC` reader - I/O Location"]
403pub type CH2LOC_R = crate::FieldReader<u8, CH2LOC_A>;
404impl CH2LOC_R {
405 #[doc = "Get enumerated values variant"]
406 #[inline(always)]
407 pub fn variant(&self) -> Option<CH2LOC_A> {
408 match self.bits {
409 0 => Some(CH2LOC_A::LOC0),
410 1 => Some(CH2LOC_A::LOC1),
411 2 => Some(CH2LOC_A::LOC2),
412 3 => Some(CH2LOC_A::LOC3),
413 4 => Some(CH2LOC_A::LOC4),
414 5 => Some(CH2LOC_A::LOC5),
415 6 => Some(CH2LOC_A::LOC6),
416 7 => Some(CH2LOC_A::LOC7),
417 _ => None,
418 }
419 }
420 #[doc = "Checks if the value of the field is `LOC0`"]
421 #[inline(always)]
422 pub fn is_loc0(&self) -> bool {
423 *self == CH2LOC_A::LOC0
424 }
425 #[doc = "Checks if the value of the field is `LOC1`"]
426 #[inline(always)]
427 pub fn is_loc1(&self) -> bool {
428 *self == CH2LOC_A::LOC1
429 }
430 #[doc = "Checks if the value of the field is `LOC2`"]
431 #[inline(always)]
432 pub fn is_loc2(&self) -> bool {
433 *self == CH2LOC_A::LOC2
434 }
435 #[doc = "Checks if the value of the field is `LOC3`"]
436 #[inline(always)]
437 pub fn is_loc3(&self) -> bool {
438 *self == CH2LOC_A::LOC3
439 }
440 #[doc = "Checks if the value of the field is `LOC4`"]
441 #[inline(always)]
442 pub fn is_loc4(&self) -> bool {
443 *self == CH2LOC_A::LOC4
444 }
445 #[doc = "Checks if the value of the field is `LOC5`"]
446 #[inline(always)]
447 pub fn is_loc5(&self) -> bool {
448 *self == CH2LOC_A::LOC5
449 }
450 #[doc = "Checks if the value of the field is `LOC6`"]
451 #[inline(always)]
452 pub fn is_loc6(&self) -> bool {
453 *self == CH2LOC_A::LOC6
454 }
455 #[doc = "Checks if the value of the field is `LOC7`"]
456 #[inline(always)]
457 pub fn is_loc7(&self) -> bool {
458 *self == CH2LOC_A::LOC7
459 }
460}
461#[doc = "Field `CH2LOC` writer - I/O Location"]
462pub type CH2LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CH2LOC_A, 6, 16>;
463impl<'a> CH2LOC_W<'a> {
464 #[doc = "Location 0"]
465 #[inline(always)]
466 pub fn loc0(self) -> &'a mut W {
467 self.variant(CH2LOC_A::LOC0)
468 }
469 #[doc = "Location 1"]
470 #[inline(always)]
471 pub fn loc1(self) -> &'a mut W {
472 self.variant(CH2LOC_A::LOC1)
473 }
474 #[doc = "Location 2"]
475 #[inline(always)]
476 pub fn loc2(self) -> &'a mut W {
477 self.variant(CH2LOC_A::LOC2)
478 }
479 #[doc = "Location 3"]
480 #[inline(always)]
481 pub fn loc3(self) -> &'a mut W {
482 self.variant(CH2LOC_A::LOC3)
483 }
484 #[doc = "Location 4"]
485 #[inline(always)]
486 pub fn loc4(self) -> &'a mut W {
487 self.variant(CH2LOC_A::LOC4)
488 }
489 #[doc = "Location 5"]
490 #[inline(always)]
491 pub fn loc5(self) -> &'a mut W {
492 self.variant(CH2LOC_A::LOC5)
493 }
494 #[doc = "Location 6"]
495 #[inline(always)]
496 pub fn loc6(self) -> &'a mut W {
497 self.variant(CH2LOC_A::LOC6)
498 }
499 #[doc = "Location 7"]
500 #[inline(always)]
501 pub fn loc7(self) -> &'a mut W {
502 self.variant(CH2LOC_A::LOC7)
503 }
504}
505#[doc = "I/O Location\n\nValue on reset: 0"]
506#[derive(Clone, Copy, Debug, PartialEq)]
507#[repr(u8)]
508pub enum CH3LOC_A {
509 #[doc = "0: Location 0"]
510 LOC0 = 0,
511 #[doc = "1: Location 1"]
512 LOC1 = 1,
513 #[doc = "2: Location 2"]
514 LOC2 = 2,
515 #[doc = "3: Location 3"]
516 LOC3 = 3,
517 #[doc = "4: Location 4"]
518 LOC4 = 4,
519 #[doc = "5: Location 5"]
520 LOC5 = 5,
521 #[doc = "6: Location 6"]
522 LOC6 = 6,
523 #[doc = "7: Location 7"]
524 LOC7 = 7,
525 #[doc = "8: Location 8"]
526 LOC8 = 8,
527 #[doc = "9: Location 9"]
528 LOC9 = 9,
529 #[doc = "10: Location 10"]
530 LOC10 = 10,
531 #[doc = "11: Location 11"]
532 LOC11 = 11,
533 #[doc = "12: Location 12"]
534 LOC12 = 12,
535 #[doc = "13: Location 13"]
536 LOC13 = 13,
537 #[doc = "14: Location 14"]
538 LOC14 = 14,
539}
540impl From<CH3LOC_A> for u8 {
541 #[inline(always)]
542 fn from(variant: CH3LOC_A) -> Self {
543 variant as _
544 }
545}
546#[doc = "Field `CH3LOC` reader - I/O Location"]
547pub type CH3LOC_R = crate::FieldReader<u8, CH3LOC_A>;
548impl CH3LOC_R {
549 #[doc = "Get enumerated values variant"]
550 #[inline(always)]
551 pub fn variant(&self) -> Option<CH3LOC_A> {
552 match self.bits {
553 0 => Some(CH3LOC_A::LOC0),
554 1 => Some(CH3LOC_A::LOC1),
555 2 => Some(CH3LOC_A::LOC2),
556 3 => Some(CH3LOC_A::LOC3),
557 4 => Some(CH3LOC_A::LOC4),
558 5 => Some(CH3LOC_A::LOC5),
559 6 => Some(CH3LOC_A::LOC6),
560 7 => Some(CH3LOC_A::LOC7),
561 8 => Some(CH3LOC_A::LOC8),
562 9 => Some(CH3LOC_A::LOC9),
563 10 => Some(CH3LOC_A::LOC10),
564 11 => Some(CH3LOC_A::LOC11),
565 12 => Some(CH3LOC_A::LOC12),
566 13 => Some(CH3LOC_A::LOC13),
567 14 => Some(CH3LOC_A::LOC14),
568 _ => None,
569 }
570 }
571 #[doc = "Checks if the value of the field is `LOC0`"]
572 #[inline(always)]
573 pub fn is_loc0(&self) -> bool {
574 *self == CH3LOC_A::LOC0
575 }
576 #[doc = "Checks if the value of the field is `LOC1`"]
577 #[inline(always)]
578 pub fn is_loc1(&self) -> bool {
579 *self == CH3LOC_A::LOC1
580 }
581 #[doc = "Checks if the value of the field is `LOC2`"]
582 #[inline(always)]
583 pub fn is_loc2(&self) -> bool {
584 *self == CH3LOC_A::LOC2
585 }
586 #[doc = "Checks if the value of the field is `LOC3`"]
587 #[inline(always)]
588 pub fn is_loc3(&self) -> bool {
589 *self == CH3LOC_A::LOC3
590 }
591 #[doc = "Checks if the value of the field is `LOC4`"]
592 #[inline(always)]
593 pub fn is_loc4(&self) -> bool {
594 *self == CH3LOC_A::LOC4
595 }
596 #[doc = "Checks if the value of the field is `LOC5`"]
597 #[inline(always)]
598 pub fn is_loc5(&self) -> bool {
599 *self == CH3LOC_A::LOC5
600 }
601 #[doc = "Checks if the value of the field is `LOC6`"]
602 #[inline(always)]
603 pub fn is_loc6(&self) -> bool {
604 *self == CH3LOC_A::LOC6
605 }
606 #[doc = "Checks if the value of the field is `LOC7`"]
607 #[inline(always)]
608 pub fn is_loc7(&self) -> bool {
609 *self == CH3LOC_A::LOC7
610 }
611 #[doc = "Checks if the value of the field is `LOC8`"]
612 #[inline(always)]
613 pub fn is_loc8(&self) -> bool {
614 *self == CH3LOC_A::LOC8
615 }
616 #[doc = "Checks if the value of the field is `LOC9`"]
617 #[inline(always)]
618 pub fn is_loc9(&self) -> bool {
619 *self == CH3LOC_A::LOC9
620 }
621 #[doc = "Checks if the value of the field is `LOC10`"]
622 #[inline(always)]
623 pub fn is_loc10(&self) -> bool {
624 *self == CH3LOC_A::LOC10
625 }
626 #[doc = "Checks if the value of the field is `LOC11`"]
627 #[inline(always)]
628 pub fn is_loc11(&self) -> bool {
629 *self == CH3LOC_A::LOC11
630 }
631 #[doc = "Checks if the value of the field is `LOC12`"]
632 #[inline(always)]
633 pub fn is_loc12(&self) -> bool {
634 *self == CH3LOC_A::LOC12
635 }
636 #[doc = "Checks if the value of the field is `LOC13`"]
637 #[inline(always)]
638 pub fn is_loc13(&self) -> bool {
639 *self == CH3LOC_A::LOC13
640 }
641 #[doc = "Checks if the value of the field is `LOC14`"]
642 #[inline(always)]
643 pub fn is_loc14(&self) -> bool {
644 *self == CH3LOC_A::LOC14
645 }
646}
647#[doc = "Field `CH3LOC` writer - I/O Location"]
648pub type CH3LOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CH3LOC_A, 6, 24>;
649impl<'a> CH3LOC_W<'a> {
650 #[doc = "Location 0"]
651 #[inline(always)]
652 pub fn loc0(self) -> &'a mut W {
653 self.variant(CH3LOC_A::LOC0)
654 }
655 #[doc = "Location 1"]
656 #[inline(always)]
657 pub fn loc1(self) -> &'a mut W {
658 self.variant(CH3LOC_A::LOC1)
659 }
660 #[doc = "Location 2"]
661 #[inline(always)]
662 pub fn loc2(self) -> &'a mut W {
663 self.variant(CH3LOC_A::LOC2)
664 }
665 #[doc = "Location 3"]
666 #[inline(always)]
667 pub fn loc3(self) -> &'a mut W {
668 self.variant(CH3LOC_A::LOC3)
669 }
670 #[doc = "Location 4"]
671 #[inline(always)]
672 pub fn loc4(self) -> &'a mut W {
673 self.variant(CH3LOC_A::LOC4)
674 }
675 #[doc = "Location 5"]
676 #[inline(always)]
677 pub fn loc5(self) -> &'a mut W {
678 self.variant(CH3LOC_A::LOC5)
679 }
680 #[doc = "Location 6"]
681 #[inline(always)]
682 pub fn loc6(self) -> &'a mut W {
683 self.variant(CH3LOC_A::LOC6)
684 }
685 #[doc = "Location 7"]
686 #[inline(always)]
687 pub fn loc7(self) -> &'a mut W {
688 self.variant(CH3LOC_A::LOC7)
689 }
690 #[doc = "Location 8"]
691 #[inline(always)]
692 pub fn loc8(self) -> &'a mut W {
693 self.variant(CH3LOC_A::LOC8)
694 }
695 #[doc = "Location 9"]
696 #[inline(always)]
697 pub fn loc9(self) -> &'a mut W {
698 self.variant(CH3LOC_A::LOC9)
699 }
700 #[doc = "Location 10"]
701 #[inline(always)]
702 pub fn loc10(self) -> &'a mut W {
703 self.variant(CH3LOC_A::LOC10)
704 }
705 #[doc = "Location 11"]
706 #[inline(always)]
707 pub fn loc11(self) -> &'a mut W {
708 self.variant(CH3LOC_A::LOC11)
709 }
710 #[doc = "Location 12"]
711 #[inline(always)]
712 pub fn loc12(self) -> &'a mut W {
713 self.variant(CH3LOC_A::LOC12)
714 }
715 #[doc = "Location 13"]
716 #[inline(always)]
717 pub fn loc13(self) -> &'a mut W {
718 self.variant(CH3LOC_A::LOC13)
719 }
720 #[doc = "Location 14"]
721 #[inline(always)]
722 pub fn loc14(self) -> &'a mut W {
723 self.variant(CH3LOC_A::LOC14)
724 }
725}
726impl R {
727 #[doc = "Bits 0:5 - I/O Location"]
728 #[inline(always)]
729 pub fn ch0loc(&self) -> CH0LOC_R {
730 CH0LOC_R::new((self.bits & 0x3f) as u8)
731 }
732 #[doc = "Bits 8:13 - I/O Location"]
733 #[inline(always)]
734 pub fn ch1loc(&self) -> CH1LOC_R {
735 CH1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
736 }
737 #[doc = "Bits 16:21 - I/O Location"]
738 #[inline(always)]
739 pub fn ch2loc(&self) -> CH2LOC_R {
740 CH2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
741 }
742 #[doc = "Bits 24:29 - I/O Location"]
743 #[inline(always)]
744 pub fn ch3loc(&self) -> CH3LOC_R {
745 CH3LOC_R::new(((self.bits >> 24) & 0x3f) as u8)
746 }
747}
748impl W {
749 #[doc = "Bits 0:5 - I/O Location"]
750 #[inline(always)]
751 pub fn ch0loc(&mut self) -> CH0LOC_W {
752 CH0LOC_W::new(self)
753 }
754 #[doc = "Bits 8:13 - I/O Location"]
755 #[inline(always)]
756 pub fn ch1loc(&mut self) -> CH1LOC_W {
757 CH1LOC_W::new(self)
758 }
759 #[doc = "Bits 16:21 - I/O Location"]
760 #[inline(always)]
761 pub fn ch2loc(&mut self) -> CH2LOC_W {
762 CH2LOC_W::new(self)
763 }
764 #[doc = "Bits 24:29 - I/O Location"]
765 #[inline(always)]
766 pub fn ch3loc(&mut self) -> CH3LOC_W {
767 CH3LOC_W::new(self)
768 }
769 #[doc = "Writes raw bits to the register."]
770 #[inline(always)]
771 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
772 self.0.bits(bits);
773 self
774 }
775}
776#[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"]
777pub struct ROUTELOC0_SPEC;
778impl crate::RegisterSpec for ROUTELOC0_SPEC {
779 type Ux = u32;
780}
781#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
782impl crate::Readable for ROUTELOC0_SPEC {
783 type Reader = R;
784}
785#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
786impl crate::Writable for ROUTELOC0_SPEC {
787 type Writer = W;
788}
789#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
790impl crate::Resettable for ROUTELOC0_SPEC {
791 #[inline(always)]
792 fn reset_value() -> Self::Ux {
793 0
794 }
795}