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