efm32gg11b510_pac/ebi/
routeloc0.rs

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 EBILOC_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}
54impl From<EBILOC_A> for u8 {
55    #[inline(always)]
56    fn from(variant: EBILOC_A) -> Self {
57        variant as _
58    }
59}
60#[doc = "Field `EBILOC` reader - I/O Location"]
61pub type EBILOC_R = crate::FieldReader<u8, EBILOC_A>;
62impl EBILOC_R {
63    #[doc = "Get enumerated values variant"]
64    #[inline(always)]
65    pub fn variant(&self) -> Option<EBILOC_A> {
66        match self.bits {
67            0 => Some(EBILOC_A::LOC0),
68            1 => Some(EBILOC_A::LOC1),
69            2 => Some(EBILOC_A::LOC2),
70            3 => Some(EBILOC_A::LOC3),
71            4 => Some(EBILOC_A::LOC4),
72            5 => Some(EBILOC_A::LOC5),
73            _ => None,
74        }
75    }
76    #[doc = "Checks if the value of the field is `LOC0`"]
77    #[inline(always)]
78    pub fn is_loc0(&self) -> bool {
79        *self == EBILOC_A::LOC0
80    }
81    #[doc = "Checks if the value of the field is `LOC1`"]
82    #[inline(always)]
83    pub fn is_loc1(&self) -> bool {
84        *self == EBILOC_A::LOC1
85    }
86    #[doc = "Checks if the value of the field is `LOC2`"]
87    #[inline(always)]
88    pub fn is_loc2(&self) -> bool {
89        *self == EBILOC_A::LOC2
90    }
91    #[doc = "Checks if the value of the field is `LOC3`"]
92    #[inline(always)]
93    pub fn is_loc3(&self) -> bool {
94        *self == EBILOC_A::LOC3
95    }
96    #[doc = "Checks if the value of the field is `LOC4`"]
97    #[inline(always)]
98    pub fn is_loc4(&self) -> bool {
99        *self == EBILOC_A::LOC4
100    }
101    #[doc = "Checks if the value of the field is `LOC5`"]
102    #[inline(always)]
103    pub fn is_loc5(&self) -> bool {
104        *self == EBILOC_A::LOC5
105    }
106}
107#[doc = "Field `EBILOC` writer - I/O Location"]
108pub type EBILOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, EBILOC_A, 6, 0>;
109impl<'a> EBILOC_W<'a> {
110    #[doc = "Location 0"]
111    #[inline(always)]
112    pub fn loc0(self) -> &'a mut W {
113        self.variant(EBILOC_A::LOC0)
114    }
115    #[doc = "Location 1"]
116    #[inline(always)]
117    pub fn loc1(self) -> &'a mut W {
118        self.variant(EBILOC_A::LOC1)
119    }
120    #[doc = "Location 2"]
121    #[inline(always)]
122    pub fn loc2(self) -> &'a mut W {
123        self.variant(EBILOC_A::LOC2)
124    }
125    #[doc = "Location 3"]
126    #[inline(always)]
127    pub fn loc3(self) -> &'a mut W {
128        self.variant(EBILOC_A::LOC3)
129    }
130    #[doc = "Location 4"]
131    #[inline(always)]
132    pub fn loc4(self) -> &'a mut W {
133        self.variant(EBILOC_A::LOC4)
134    }
135    #[doc = "Location 5"]
136    #[inline(always)]
137    pub fn loc5(self) -> &'a mut W {
138        self.variant(EBILOC_A::LOC5)
139    }
140}
141#[doc = "I/O Location\n\nValue on reset: 0"]
142#[derive(Clone, Copy, Debug, PartialEq)]
143#[repr(u8)]
144pub enum CSLOC_A {
145    #[doc = "0: Location 0"]
146    LOC0 = 0,
147    #[doc = "1: Location 1"]
148    LOC1 = 1,
149    #[doc = "2: Location 2"]
150    LOC2 = 2,
151    #[doc = "3: Location 3"]
152    LOC3 = 3,
153    #[doc = "4: Location 4"]
154    LOC4 = 4,
155}
156impl From<CSLOC_A> for u8 {
157    #[inline(always)]
158    fn from(variant: CSLOC_A) -> Self {
159        variant as _
160    }
161}
162#[doc = "Field `CSLOC` reader - I/O Location"]
163pub type CSLOC_R = crate::FieldReader<u8, CSLOC_A>;
164impl CSLOC_R {
165    #[doc = "Get enumerated values variant"]
166    #[inline(always)]
167    pub fn variant(&self) -> Option<CSLOC_A> {
168        match self.bits {
169            0 => Some(CSLOC_A::LOC0),
170            1 => Some(CSLOC_A::LOC1),
171            2 => Some(CSLOC_A::LOC2),
172            3 => Some(CSLOC_A::LOC3),
173            4 => Some(CSLOC_A::LOC4),
174            _ => None,
175        }
176    }
177    #[doc = "Checks if the value of the field is `LOC0`"]
178    #[inline(always)]
179    pub fn is_loc0(&self) -> bool {
180        *self == CSLOC_A::LOC0
181    }
182    #[doc = "Checks if the value of the field is `LOC1`"]
183    #[inline(always)]
184    pub fn is_loc1(&self) -> bool {
185        *self == CSLOC_A::LOC1
186    }
187    #[doc = "Checks if the value of the field is `LOC2`"]
188    #[inline(always)]
189    pub fn is_loc2(&self) -> bool {
190        *self == CSLOC_A::LOC2
191    }
192    #[doc = "Checks if the value of the field is `LOC3`"]
193    #[inline(always)]
194    pub fn is_loc3(&self) -> bool {
195        *self == CSLOC_A::LOC3
196    }
197    #[doc = "Checks if the value of the field is `LOC4`"]
198    #[inline(always)]
199    pub fn is_loc4(&self) -> bool {
200        *self == CSLOC_A::LOC4
201    }
202}
203#[doc = "Field `CSLOC` writer - I/O Location"]
204pub type CSLOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, CSLOC_A, 6, 8>;
205impl<'a> CSLOC_W<'a> {
206    #[doc = "Location 0"]
207    #[inline(always)]
208    pub fn loc0(self) -> &'a mut W {
209        self.variant(CSLOC_A::LOC0)
210    }
211    #[doc = "Location 1"]
212    #[inline(always)]
213    pub fn loc1(self) -> &'a mut W {
214        self.variant(CSLOC_A::LOC1)
215    }
216    #[doc = "Location 2"]
217    #[inline(always)]
218    pub fn loc2(self) -> &'a mut W {
219        self.variant(CSLOC_A::LOC2)
220    }
221    #[doc = "Location 3"]
222    #[inline(always)]
223    pub fn loc3(self) -> &'a mut W {
224        self.variant(CSLOC_A::LOC3)
225    }
226    #[doc = "Location 4"]
227    #[inline(always)]
228    pub fn loc4(self) -> &'a mut W {
229        self.variant(CSLOC_A::LOC4)
230    }
231}
232#[doc = "I/O Location\n\nValue on reset: 0"]
233#[derive(Clone, Copy, Debug, PartialEq)]
234#[repr(u8)]
235pub enum NANDLOC_A {
236    #[doc = "0: Location 0"]
237    LOC0 = 0,
238    #[doc = "1: Location 1"]
239    LOC1 = 1,
240    #[doc = "2: Location 2"]
241    LOC2 = 2,
242    #[doc = "3: Location 3"]
243    LOC3 = 3,
244    #[doc = "4: Location 4"]
245    LOC4 = 4,
246    #[doc = "5: Location 5"]
247    LOC5 = 5,
248}
249impl From<NANDLOC_A> for u8 {
250    #[inline(always)]
251    fn from(variant: NANDLOC_A) -> Self {
252        variant as _
253    }
254}
255#[doc = "Field `NANDLOC` reader - I/O Location"]
256pub type NANDLOC_R = crate::FieldReader<u8, NANDLOC_A>;
257impl NANDLOC_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> Option<NANDLOC_A> {
261        match self.bits {
262            0 => Some(NANDLOC_A::LOC0),
263            1 => Some(NANDLOC_A::LOC1),
264            2 => Some(NANDLOC_A::LOC2),
265            3 => Some(NANDLOC_A::LOC3),
266            4 => Some(NANDLOC_A::LOC4),
267            5 => Some(NANDLOC_A::LOC5),
268            _ => None,
269        }
270    }
271    #[doc = "Checks if the value of the field is `LOC0`"]
272    #[inline(always)]
273    pub fn is_loc0(&self) -> bool {
274        *self == NANDLOC_A::LOC0
275    }
276    #[doc = "Checks if the value of the field is `LOC1`"]
277    #[inline(always)]
278    pub fn is_loc1(&self) -> bool {
279        *self == NANDLOC_A::LOC1
280    }
281    #[doc = "Checks if the value of the field is `LOC2`"]
282    #[inline(always)]
283    pub fn is_loc2(&self) -> bool {
284        *self == NANDLOC_A::LOC2
285    }
286    #[doc = "Checks if the value of the field is `LOC3`"]
287    #[inline(always)]
288    pub fn is_loc3(&self) -> bool {
289        *self == NANDLOC_A::LOC3
290    }
291    #[doc = "Checks if the value of the field is `LOC4`"]
292    #[inline(always)]
293    pub fn is_loc4(&self) -> bool {
294        *self == NANDLOC_A::LOC4
295    }
296    #[doc = "Checks if the value of the field is `LOC5`"]
297    #[inline(always)]
298    pub fn is_loc5(&self) -> bool {
299        *self == NANDLOC_A::LOC5
300    }
301}
302#[doc = "Field `NANDLOC` writer - I/O Location"]
303pub type NANDLOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, NANDLOC_A, 6, 16>;
304impl<'a> NANDLOC_W<'a> {
305    #[doc = "Location 0"]
306    #[inline(always)]
307    pub fn loc0(self) -> &'a mut W {
308        self.variant(NANDLOC_A::LOC0)
309    }
310    #[doc = "Location 1"]
311    #[inline(always)]
312    pub fn loc1(self) -> &'a mut W {
313        self.variant(NANDLOC_A::LOC1)
314    }
315    #[doc = "Location 2"]
316    #[inline(always)]
317    pub fn loc2(self) -> &'a mut W {
318        self.variant(NANDLOC_A::LOC2)
319    }
320    #[doc = "Location 3"]
321    #[inline(always)]
322    pub fn loc3(self) -> &'a mut W {
323        self.variant(NANDLOC_A::LOC3)
324    }
325    #[doc = "Location 4"]
326    #[inline(always)]
327    pub fn loc4(self) -> &'a mut W {
328        self.variant(NANDLOC_A::LOC4)
329    }
330    #[doc = "Location 5"]
331    #[inline(always)]
332    pub fn loc5(self) -> &'a mut W {
333        self.variant(NANDLOC_A::LOC5)
334    }
335}
336#[doc = "I/O Location\n\nValue on reset: 0"]
337#[derive(Clone, Copy, Debug, PartialEq)]
338#[repr(u8)]
339pub enum TFTLOC_A {
340    #[doc = "0: Location 0"]
341    LOC0 = 0,
342    #[doc = "1: Location 1"]
343    LOC1 = 1,
344    #[doc = "2: Location 2"]
345    LOC2 = 2,
346    #[doc = "3: Location 3"]
347    LOC3 = 3,
348}
349impl From<TFTLOC_A> for u8 {
350    #[inline(always)]
351    fn from(variant: TFTLOC_A) -> Self {
352        variant as _
353    }
354}
355#[doc = "Field `TFTLOC` reader - I/O Location"]
356pub type TFTLOC_R = crate::FieldReader<u8, TFTLOC_A>;
357impl TFTLOC_R {
358    #[doc = "Get enumerated values variant"]
359    #[inline(always)]
360    pub fn variant(&self) -> Option<TFTLOC_A> {
361        match self.bits {
362            0 => Some(TFTLOC_A::LOC0),
363            1 => Some(TFTLOC_A::LOC1),
364            2 => Some(TFTLOC_A::LOC2),
365            3 => Some(TFTLOC_A::LOC3),
366            _ => None,
367        }
368    }
369    #[doc = "Checks if the value of the field is `LOC0`"]
370    #[inline(always)]
371    pub fn is_loc0(&self) -> bool {
372        *self == TFTLOC_A::LOC0
373    }
374    #[doc = "Checks if the value of the field is `LOC1`"]
375    #[inline(always)]
376    pub fn is_loc1(&self) -> bool {
377        *self == TFTLOC_A::LOC1
378    }
379    #[doc = "Checks if the value of the field is `LOC2`"]
380    #[inline(always)]
381    pub fn is_loc2(&self) -> bool {
382        *self == TFTLOC_A::LOC2
383    }
384    #[doc = "Checks if the value of the field is `LOC3`"]
385    #[inline(always)]
386    pub fn is_loc3(&self) -> bool {
387        *self == TFTLOC_A::LOC3
388    }
389}
390#[doc = "Field `TFTLOC` writer - I/O Location"]
391pub type TFTLOC_W<'a> = crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, TFTLOC_A, 6, 24>;
392impl<'a> TFTLOC_W<'a> {
393    #[doc = "Location 0"]
394    #[inline(always)]
395    pub fn loc0(self) -> &'a mut W {
396        self.variant(TFTLOC_A::LOC0)
397    }
398    #[doc = "Location 1"]
399    #[inline(always)]
400    pub fn loc1(self) -> &'a mut W {
401        self.variant(TFTLOC_A::LOC1)
402    }
403    #[doc = "Location 2"]
404    #[inline(always)]
405    pub fn loc2(self) -> &'a mut W {
406        self.variant(TFTLOC_A::LOC2)
407    }
408    #[doc = "Location 3"]
409    #[inline(always)]
410    pub fn loc3(self) -> &'a mut W {
411        self.variant(TFTLOC_A::LOC3)
412    }
413}
414impl R {
415    #[doc = "Bits 0:5 - I/O Location"]
416    #[inline(always)]
417    pub fn ebiloc(&self) -> EBILOC_R {
418        EBILOC_R::new((self.bits & 0x3f) as u8)
419    }
420    #[doc = "Bits 8:13 - I/O Location"]
421    #[inline(always)]
422    pub fn csloc(&self) -> CSLOC_R {
423        CSLOC_R::new(((self.bits >> 8) & 0x3f) as u8)
424    }
425    #[doc = "Bits 16:21 - I/O Location"]
426    #[inline(always)]
427    pub fn nandloc(&self) -> NANDLOC_R {
428        NANDLOC_R::new(((self.bits >> 16) & 0x3f) as u8)
429    }
430    #[doc = "Bits 24:29 - I/O Location"]
431    #[inline(always)]
432    pub fn tftloc(&self) -> TFTLOC_R {
433        TFTLOC_R::new(((self.bits >> 24) & 0x3f) as u8)
434    }
435}
436impl W {
437    #[doc = "Bits 0:5 - I/O Location"]
438    #[inline(always)]
439    pub fn ebiloc(&mut self) -> EBILOC_W {
440        EBILOC_W::new(self)
441    }
442    #[doc = "Bits 8:13 - I/O Location"]
443    #[inline(always)]
444    pub fn csloc(&mut self) -> CSLOC_W {
445        CSLOC_W::new(self)
446    }
447    #[doc = "Bits 16:21 - I/O Location"]
448    #[inline(always)]
449    pub fn nandloc(&mut self) -> NANDLOC_W {
450        NANDLOC_W::new(self)
451    }
452    #[doc = "Bits 24:29 - I/O Location"]
453    #[inline(always)]
454    pub fn tftloc(&mut self) -> TFTLOC_W {
455        TFTLOC_W::new(self)
456    }
457    #[doc = "Writes raw bits to the register."]
458    #[inline(always)]
459    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
460        self.0.bits(bits);
461        self
462    }
463}
464#[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"]
465pub struct ROUTELOC0_SPEC;
466impl crate::RegisterSpec for ROUTELOC0_SPEC {
467    type Ux = u32;
468}
469#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
470impl crate::Readable for ROUTELOC0_SPEC {
471    type Reader = R;
472}
473#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
474impl crate::Writable for ROUTELOC0_SPEC {
475    type Writer = W;
476}
477#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
478impl crate::Resettable for ROUTELOC0_SPEC {
479    #[inline(always)]
480    fn reset_value() -> Self::Ux {
481        0
482    }
483}
efm32gg11b510_pac/ebi/routeloc0.rs

efm32gg11b510_pac/ebi/
routeloc0.rs
