efm32pg12_pac/prs/
routeloc1.rs

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

efm32pg12_pac/prs/
routeloc1.rs
