efm32pg12_pac/gpio/
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 ETMTCLKLOC_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}
26impl From<ETMTCLKLOC_A> for u8 {
27    #[inline(always)]
28    fn from(variant: ETMTCLKLOC_A) -> Self {
29        variant as _
30    }
31}
32#[doc = "Reader of field `ETMTCLKLOC`"]
33pub type ETMTCLKLOC_R = crate::R<u8, ETMTCLKLOC_A>;
34impl ETMTCLKLOC_R {
35    #[doc = r"Get enumerated values variant"]
36    #[inline(always)]
37    pub fn variant(&self) -> crate::Variant<u8, ETMTCLKLOC_A> {
38        use crate::Variant::*;
39        match self.bits {
40            0 => Val(ETMTCLKLOC_A::LOC0),
41            1 => Val(ETMTCLKLOC_A::LOC1),
42            2 => Val(ETMTCLKLOC_A::LOC2),
43            3 => Val(ETMTCLKLOC_A::LOC3),
44            i => Res(i),
45        }
46    }
47    #[doc = "Checks if the value of the field is `LOC0`"]
48    #[inline(always)]
49    pub fn is_loc0(&self) -> bool {
50        *self == ETMTCLKLOC_A::LOC0
51    }
52    #[doc = "Checks if the value of the field is `LOC1`"]
53    #[inline(always)]
54    pub fn is_loc1(&self) -> bool {
55        *self == ETMTCLKLOC_A::LOC1
56    }
57    #[doc = "Checks if the value of the field is `LOC2`"]
58    #[inline(always)]
59    pub fn is_loc2(&self) -> bool {
60        *self == ETMTCLKLOC_A::LOC2
61    }
62    #[doc = "Checks if the value of the field is `LOC3`"]
63    #[inline(always)]
64    pub fn is_loc3(&self) -> bool {
65        *self == ETMTCLKLOC_A::LOC3
66    }
67}
68#[doc = "Write proxy for field `ETMTCLKLOC`"]
69pub struct ETMTCLKLOC_W<'a> {
70    w: &'a mut W,
71}
72impl<'a> ETMTCLKLOC_W<'a> {
73    #[doc = r"Writes `variant` to the field"]
74    #[inline(always)]
75    pub fn variant(self, variant: ETMTCLKLOC_A) -> &'a mut W {
76        unsafe { self.bits(variant.into()) }
77    }
78    #[doc = "Location 0"]
79    #[inline(always)]
80    pub fn loc0(self) -> &'a mut W {
81        self.variant(ETMTCLKLOC_A::LOC0)
82    }
83    #[doc = "Location 1"]
84    #[inline(always)]
85    pub fn loc1(self) -> &'a mut W {
86        self.variant(ETMTCLKLOC_A::LOC1)
87    }
88    #[doc = "Location 2"]
89    #[inline(always)]
90    pub fn loc2(self) -> &'a mut W {
91        self.variant(ETMTCLKLOC_A::LOC2)
92    }
93    #[doc = "Location 3"]
94    #[inline(always)]
95    pub fn loc3(self) -> &'a mut W {
96        self.variant(ETMTCLKLOC_A::LOC3)
97    }
98    #[doc = r"Writes raw bits to the field"]
99    #[inline(always)]
100    pub unsafe fn bits(self, value: u8) -> &'a mut W {
101        self.w.bits = (self.w.bits & !0x3f) | ((value as u32) & 0x3f);
102        self.w
103    }
104}
105#[doc = "I/O Location\n\nValue on reset: 0"]
106#[derive(Clone, Copy, Debug, PartialEq)]
107#[repr(u8)]
108pub enum ETMTD0LOC_A {
109    #[doc = "0: Location 0"]
110    LOC0 = 0,
111    #[doc = "1: Location 1"]
112    LOC1 = 1,
113    #[doc = "2: Location 2"]
114    LOC2 = 2,
115    #[doc = "3: Location 3"]
116    LOC3 = 3,
117}
118impl From<ETMTD0LOC_A> for u8 {
119    #[inline(always)]
120    fn from(variant: ETMTD0LOC_A) -> Self {
121        variant as _
122    }
123}
124#[doc = "Reader of field `ETMTD0LOC`"]
125pub type ETMTD0LOC_R = crate::R<u8, ETMTD0LOC_A>;
126impl ETMTD0LOC_R {
127    #[doc = r"Get enumerated values variant"]
128    #[inline(always)]
129    pub fn variant(&self) -> crate::Variant<u8, ETMTD0LOC_A> {
130        use crate::Variant::*;
131        match self.bits {
132            0 => Val(ETMTD0LOC_A::LOC0),
133            1 => Val(ETMTD0LOC_A::LOC1),
134            2 => Val(ETMTD0LOC_A::LOC2),
135            3 => Val(ETMTD0LOC_A::LOC3),
136            i => Res(i),
137        }
138    }
139    #[doc = "Checks if the value of the field is `LOC0`"]
140    #[inline(always)]
141    pub fn is_loc0(&self) -> bool {
142        *self == ETMTD0LOC_A::LOC0
143    }
144    #[doc = "Checks if the value of the field is `LOC1`"]
145    #[inline(always)]
146    pub fn is_loc1(&self) -> bool {
147        *self == ETMTD0LOC_A::LOC1
148    }
149    #[doc = "Checks if the value of the field is `LOC2`"]
150    #[inline(always)]
151    pub fn is_loc2(&self) -> bool {
152        *self == ETMTD0LOC_A::LOC2
153    }
154    #[doc = "Checks if the value of the field is `LOC3`"]
155    #[inline(always)]
156    pub fn is_loc3(&self) -> bool {
157        *self == ETMTD0LOC_A::LOC3
158    }
159}
160#[doc = "Write proxy for field `ETMTD0LOC`"]
161pub struct ETMTD0LOC_W<'a> {
162    w: &'a mut W,
163}
164impl<'a> ETMTD0LOC_W<'a> {
165    #[doc = r"Writes `variant` to the field"]
166    #[inline(always)]
167    pub fn variant(self, variant: ETMTD0LOC_A) -> &'a mut W {
168        unsafe { self.bits(variant.into()) }
169    }
170    #[doc = "Location 0"]
171    #[inline(always)]
172    pub fn loc0(self) -> &'a mut W {
173        self.variant(ETMTD0LOC_A::LOC0)
174    }
175    #[doc = "Location 1"]
176    #[inline(always)]
177    pub fn loc1(self) -> &'a mut W {
178        self.variant(ETMTD0LOC_A::LOC1)
179    }
180    #[doc = "Location 2"]
181    #[inline(always)]
182    pub fn loc2(self) -> &'a mut W {
183        self.variant(ETMTD0LOC_A::LOC2)
184    }
185    #[doc = "Location 3"]
186    #[inline(always)]
187    pub fn loc3(self) -> &'a mut W {
188        self.variant(ETMTD0LOC_A::LOC3)
189    }
190    #[doc = r"Writes raw bits to the field"]
191    #[inline(always)]
192    pub unsafe fn bits(self, value: u8) -> &'a mut W {
193        self.w.bits = (self.w.bits & !(0x3f << 8)) | (((value as u32) & 0x3f) << 8);
194        self.w
195    }
196}
197#[doc = "I/O Location\n\nValue on reset: 0"]
198#[derive(Clone, Copy, Debug, PartialEq)]
199#[repr(u8)]
200pub enum ETMTD1LOC_A {
201    #[doc = "0: Location 0"]
202    LOC0 = 0,
203    #[doc = "1: Location 1"]
204    LOC1 = 1,
205    #[doc = "2: Location 2"]
206    LOC2 = 2,
207    #[doc = "3: Location 3"]
208    LOC3 = 3,
209}
210impl From<ETMTD1LOC_A> for u8 {
211    #[inline(always)]
212    fn from(variant: ETMTD1LOC_A) -> Self {
213        variant as _
214    }
215}
216#[doc = "Reader of field `ETMTD1LOC`"]
217pub type ETMTD1LOC_R = crate::R<u8, ETMTD1LOC_A>;
218impl ETMTD1LOC_R {
219    #[doc = r"Get enumerated values variant"]
220    #[inline(always)]
221    pub fn variant(&self) -> crate::Variant<u8, ETMTD1LOC_A> {
222        use crate::Variant::*;
223        match self.bits {
224            0 => Val(ETMTD1LOC_A::LOC0),
225            1 => Val(ETMTD1LOC_A::LOC1),
226            2 => Val(ETMTD1LOC_A::LOC2),
227            3 => Val(ETMTD1LOC_A::LOC3),
228            i => Res(i),
229        }
230    }
231    #[doc = "Checks if the value of the field is `LOC0`"]
232    #[inline(always)]
233    pub fn is_loc0(&self) -> bool {
234        *self == ETMTD1LOC_A::LOC0
235    }
236    #[doc = "Checks if the value of the field is `LOC1`"]
237    #[inline(always)]
238    pub fn is_loc1(&self) -> bool {
239        *self == ETMTD1LOC_A::LOC1
240    }
241    #[doc = "Checks if the value of the field is `LOC2`"]
242    #[inline(always)]
243    pub fn is_loc2(&self) -> bool {
244        *self == ETMTD1LOC_A::LOC2
245    }
246    #[doc = "Checks if the value of the field is `LOC3`"]
247    #[inline(always)]
248    pub fn is_loc3(&self) -> bool {
249        *self == ETMTD1LOC_A::LOC3
250    }
251}
252#[doc = "Write proxy for field `ETMTD1LOC`"]
253pub struct ETMTD1LOC_W<'a> {
254    w: &'a mut W,
255}
256impl<'a> ETMTD1LOC_W<'a> {
257    #[doc = r"Writes `variant` to the field"]
258    #[inline(always)]
259    pub fn variant(self, variant: ETMTD1LOC_A) -> &'a mut W {
260        unsafe { self.bits(variant.into()) }
261    }
262    #[doc = "Location 0"]
263    #[inline(always)]
264    pub fn loc0(self) -> &'a mut W {
265        self.variant(ETMTD1LOC_A::LOC0)
266    }
267    #[doc = "Location 1"]
268    #[inline(always)]
269    pub fn loc1(self) -> &'a mut W {
270        self.variant(ETMTD1LOC_A::LOC1)
271    }
272    #[doc = "Location 2"]
273    #[inline(always)]
274    pub fn loc2(self) -> &'a mut W {
275        self.variant(ETMTD1LOC_A::LOC2)
276    }
277    #[doc = "Location 3"]
278    #[inline(always)]
279    pub fn loc3(self) -> &'a mut W {
280        self.variant(ETMTD1LOC_A::LOC3)
281    }
282    #[doc = r"Writes raw bits to the field"]
283    #[inline(always)]
284    pub unsafe fn bits(self, value: u8) -> &'a mut W {
285        self.w.bits = (self.w.bits & !(0x3f << 14)) | (((value as u32) & 0x3f) << 14);
286        self.w
287    }
288}
289#[doc = "I/O Location\n\nValue on reset: 0"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291#[repr(u8)]
292pub enum ETMTD2LOC_A {
293    #[doc = "0: Location 0"]
294    LOC0 = 0,
295    #[doc = "1: Location 1"]
296    LOC1 = 1,
297    #[doc = "2: Location 2"]
298    LOC2 = 2,
299    #[doc = "3: Location 3"]
300    LOC3 = 3,
301}
302impl From<ETMTD2LOC_A> for u8 {
303    #[inline(always)]
304    fn from(variant: ETMTD2LOC_A) -> Self {
305        variant as _
306    }
307}
308#[doc = "Reader of field `ETMTD2LOC`"]
309pub type ETMTD2LOC_R = crate::R<u8, ETMTD2LOC_A>;
310impl ETMTD2LOC_R {
311    #[doc = r"Get enumerated values variant"]
312    #[inline(always)]
313    pub fn variant(&self) -> crate::Variant<u8, ETMTD2LOC_A> {
314        use crate::Variant::*;
315        match self.bits {
316            0 => Val(ETMTD2LOC_A::LOC0),
317            1 => Val(ETMTD2LOC_A::LOC1),
318            2 => Val(ETMTD2LOC_A::LOC2),
319            3 => Val(ETMTD2LOC_A::LOC3),
320            i => Res(i),
321        }
322    }
323    #[doc = "Checks if the value of the field is `LOC0`"]
324    #[inline(always)]
325    pub fn is_loc0(&self) -> bool {
326        *self == ETMTD2LOC_A::LOC0
327    }
328    #[doc = "Checks if the value of the field is `LOC1`"]
329    #[inline(always)]
330    pub fn is_loc1(&self) -> bool {
331        *self == ETMTD2LOC_A::LOC1
332    }
333    #[doc = "Checks if the value of the field is `LOC2`"]
334    #[inline(always)]
335    pub fn is_loc2(&self) -> bool {
336        *self == ETMTD2LOC_A::LOC2
337    }
338    #[doc = "Checks if the value of the field is `LOC3`"]
339    #[inline(always)]
340    pub fn is_loc3(&self) -> bool {
341        *self == ETMTD2LOC_A::LOC3
342    }
343}
344#[doc = "Write proxy for field `ETMTD2LOC`"]
345pub struct ETMTD2LOC_W<'a> {
346    w: &'a mut W,
347}
348impl<'a> ETMTD2LOC_W<'a> {
349    #[doc = r"Writes `variant` to the field"]
350    #[inline(always)]
351    pub fn variant(self, variant: ETMTD2LOC_A) -> &'a mut W {
352        unsafe { self.bits(variant.into()) }
353    }
354    #[doc = "Location 0"]
355    #[inline(always)]
356    pub fn loc0(self) -> &'a mut W {
357        self.variant(ETMTD2LOC_A::LOC0)
358    }
359    #[doc = "Location 1"]
360    #[inline(always)]
361    pub fn loc1(self) -> &'a mut W {
362        self.variant(ETMTD2LOC_A::LOC1)
363    }
364    #[doc = "Location 2"]
365    #[inline(always)]
366    pub fn loc2(self) -> &'a mut W {
367        self.variant(ETMTD2LOC_A::LOC2)
368    }
369    #[doc = "Location 3"]
370    #[inline(always)]
371    pub fn loc3(self) -> &'a mut W {
372        self.variant(ETMTD2LOC_A::LOC3)
373    }
374    #[doc = r"Writes raw bits to the field"]
375    #[inline(always)]
376    pub unsafe fn bits(self, value: u8) -> &'a mut W {
377        self.w.bits = (self.w.bits & !(0x3f << 20)) | (((value as u32) & 0x3f) << 20);
378        self.w
379    }
380}
381#[doc = "I/O Location\n\nValue on reset: 0"]
382#[derive(Clone, Copy, Debug, PartialEq)]
383#[repr(u8)]
384pub enum ETMTD3LOC_A {
385    #[doc = "0: Location 0"]
386    LOC0 = 0,
387    #[doc = "1: Location 1"]
388    LOC1 = 1,
389    #[doc = "2: Location 2"]
390    LOC2 = 2,
391    #[doc = "3: Location 3"]
392    LOC3 = 3,
393}
394impl From<ETMTD3LOC_A> for u8 {
395    #[inline(always)]
396    fn from(variant: ETMTD3LOC_A) -> Self {
397        variant as _
398    }
399}
400#[doc = "Reader of field `ETMTD3LOC`"]
401pub type ETMTD3LOC_R = crate::R<u8, ETMTD3LOC_A>;
402impl ETMTD3LOC_R {
403    #[doc = r"Get enumerated values variant"]
404    #[inline(always)]
405    pub fn variant(&self) -> crate::Variant<u8, ETMTD3LOC_A> {
406        use crate::Variant::*;
407        match self.bits {
408            0 => Val(ETMTD3LOC_A::LOC0),
409            1 => Val(ETMTD3LOC_A::LOC1),
410            2 => Val(ETMTD3LOC_A::LOC2),
411            3 => Val(ETMTD3LOC_A::LOC3),
412            i => Res(i),
413        }
414    }
415    #[doc = "Checks if the value of the field is `LOC0`"]
416    #[inline(always)]
417    pub fn is_loc0(&self) -> bool {
418        *self == ETMTD3LOC_A::LOC0
419    }
420    #[doc = "Checks if the value of the field is `LOC1`"]
421    #[inline(always)]
422    pub fn is_loc1(&self) -> bool {
423        *self == ETMTD3LOC_A::LOC1
424    }
425    #[doc = "Checks if the value of the field is `LOC2`"]
426    #[inline(always)]
427    pub fn is_loc2(&self) -> bool {
428        *self == ETMTD3LOC_A::LOC2
429    }
430    #[doc = "Checks if the value of the field is `LOC3`"]
431    #[inline(always)]
432    pub fn is_loc3(&self) -> bool {
433        *self == ETMTD3LOC_A::LOC3
434    }
435}
436#[doc = "Write proxy for field `ETMTD3LOC`"]
437pub struct ETMTD3LOC_W<'a> {
438    w: &'a mut W,
439}
440impl<'a> ETMTD3LOC_W<'a> {
441    #[doc = r"Writes `variant` to the field"]
442    #[inline(always)]
443    pub fn variant(self, variant: ETMTD3LOC_A) -> &'a mut W {
444        unsafe { self.bits(variant.into()) }
445    }
446    #[doc = "Location 0"]
447    #[inline(always)]
448    pub fn loc0(self) -> &'a mut W {
449        self.variant(ETMTD3LOC_A::LOC0)
450    }
451    #[doc = "Location 1"]
452    #[inline(always)]
453    pub fn loc1(self) -> &'a mut W {
454        self.variant(ETMTD3LOC_A::LOC1)
455    }
456    #[doc = "Location 2"]
457    #[inline(always)]
458    pub fn loc2(self) -> &'a mut W {
459        self.variant(ETMTD3LOC_A::LOC2)
460    }
461    #[doc = "Location 3"]
462    #[inline(always)]
463    pub fn loc3(self) -> &'a mut W {
464        self.variant(ETMTD3LOC_A::LOC3)
465    }
466    #[doc = r"Writes raw bits to the field"]
467    #[inline(always)]
468    pub unsafe fn bits(self, value: u8) -> &'a mut W {
469        self.w.bits = (self.w.bits & !(0x3f << 26)) | (((value as u32) & 0x3f) << 26);
470        self.w
471    }
472}
473impl R {
474    #[doc = "Bits 0:5 - I/O Location"]
475    #[inline(always)]
476    pub fn etmtclkloc(&self) -> ETMTCLKLOC_R {
477        ETMTCLKLOC_R::new((self.bits & 0x3f) as u8)
478    }
479    #[doc = "Bits 8:13 - I/O Location"]
480    #[inline(always)]
481    pub fn etmtd0loc(&self) -> ETMTD0LOC_R {
482        ETMTD0LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
483    }
484    #[doc = "Bits 14:19 - I/O Location"]
485    #[inline(always)]
486    pub fn etmtd1loc(&self) -> ETMTD1LOC_R {
487        ETMTD1LOC_R::new(((self.bits >> 14) & 0x3f) as u8)
488    }
489    #[doc = "Bits 20:25 - I/O Location"]
490    #[inline(always)]
491    pub fn etmtd2loc(&self) -> ETMTD2LOC_R {
492        ETMTD2LOC_R::new(((self.bits >> 20) & 0x3f) as u8)
493    }
494    #[doc = "Bits 26:31 - I/O Location"]
495    #[inline(always)]
496    pub fn etmtd3loc(&self) -> ETMTD3LOC_R {
497        ETMTD3LOC_R::new(((self.bits >> 26) & 0x3f) as u8)
498    }
499}
500impl W {
501    #[doc = "Bits 0:5 - I/O Location"]
502    #[inline(always)]
503    pub fn etmtclkloc(&mut self) -> ETMTCLKLOC_W {
504        ETMTCLKLOC_W { w: self }
505    }
506    #[doc = "Bits 8:13 - I/O Location"]
507    #[inline(always)]
508    pub fn etmtd0loc(&mut self) -> ETMTD0LOC_W {
509        ETMTD0LOC_W { w: self }
510    }
511    #[doc = "Bits 14:19 - I/O Location"]
512    #[inline(always)]
513    pub fn etmtd1loc(&mut self) -> ETMTD1LOC_W {
514        ETMTD1LOC_W { w: self }
515    }
516    #[doc = "Bits 20:25 - I/O Location"]
517    #[inline(always)]
518    pub fn etmtd2loc(&mut self) -> ETMTD2LOC_W {
519        ETMTD2LOC_W { w: self }
520    }
521    #[doc = "Bits 26:31 - I/O Location"]
522    #[inline(always)]
523    pub fn etmtd3loc(&mut self) -> ETMTD3LOC_W {
524        ETMTD3LOC_W { w: self }
525    }
526}
efm32pg12_pac/gpio/routeloc1.rs

efm32pg12_pac/gpio/
routeloc1.rs
