efm32gg_pac/efm32gg995/ebi/
route.rs

1#[doc = "Register `ROUTE` reader"]
2pub struct R(crate::R<ROUTE_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<ROUTE_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<ROUTE_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<ROUTE_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `ROUTE` writer"]
17pub struct W(crate::W<ROUTE_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<ROUTE_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<ROUTE_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<ROUTE_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `EBIPEN` reader - EBI Pin Enable"]
38pub type EBIPEN_R = crate::BitReader<bool>;
39#[doc = "Field `EBIPEN` writer - EBI Pin Enable"]
40pub type EBIPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
41#[doc = "Field `CS0PEN` reader - EBI_CS0 Pin Enable"]
42pub type CS0PEN_R = crate::BitReader<bool>;
43#[doc = "Field `CS0PEN` writer - EBI_CS0 Pin Enable"]
44pub type CS0PEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
45#[doc = "Field `CS1PEN` reader - EBI_CS1 Pin Enable"]
46pub type CS1PEN_R = crate::BitReader<bool>;
47#[doc = "Field `CS1PEN` writer - EBI_CS1 Pin Enable"]
48pub type CS1PEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
49#[doc = "Field `CS2PEN` reader - EBI_CS2 Pin Enable"]
50pub type CS2PEN_R = crate::BitReader<bool>;
51#[doc = "Field `CS2PEN` writer - EBI_CS2 Pin Enable"]
52pub type CS2PEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
53#[doc = "Field `CS3PEN` reader - EBI_CS3 Pin Enable"]
54pub type CS3PEN_R = crate::BitReader<bool>;
55#[doc = "Field `CS3PEN` writer - EBI_CS3 Pin Enable"]
56pub type CS3PEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
57#[doc = "Field `ALEPEN` reader - EBI_ALE Pin Enable"]
58pub type ALEPEN_R = crate::BitReader<bool>;
59#[doc = "Field `ALEPEN` writer - EBI_ALE Pin Enable"]
60pub type ALEPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
61#[doc = "Field `ARDYPEN` reader - EBI_ARDY Pin Enable"]
62pub type ARDYPEN_R = crate::BitReader<bool>;
63#[doc = "Field `ARDYPEN` writer - EBI_ARDY Pin Enable"]
64pub type ARDYPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
65#[doc = "Field `BLPEN` reader - EBI_BL\\[1:0\\]
66Pin Enable"]
67pub type BLPEN_R = crate::BitReader<bool>;
68#[doc = "Field `BLPEN` writer - EBI_BL\\[1:0\\]
69Pin Enable"]
70pub type BLPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
71#[doc = "Field `NANDPEN` reader - NANDRE and NANDWE Pin Enable"]
72pub type NANDPEN_R = crate::BitReader<bool>;
73#[doc = "Field `NANDPEN` writer - NANDRE and NANDWE Pin Enable"]
74pub type NANDPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
75#[doc = "Field `ALB` reader - Sets the lower bound for EBI_A enabling"]
76pub type ALB_R = crate::FieldReader<u8, ALB_A>;
77#[doc = "Sets the lower bound for EBI_A enabling\n\nValue on reset: 0"]
78#[derive(Clone, Copy, Debug, PartialEq, Eq)]
79#[repr(u8)]
80pub enum ALB_A {
81    #[doc = "0: Address lines from EBI_A\\[0\\]
82and upwards can be enabled via APEN."]
83    A0 = 0,
84    #[doc = "1: Address lines from EBI_A\\[8\\]
85and upwards can be enabled via APEN."]
86    A8 = 1,
87    #[doc = "2: Address lines from EBI_A\\[16\\]
88and upwards can be enabled via APEN."]
89    A16 = 2,
90    #[doc = "3: Address lines from EBI_A\\[24\\]
91and upwards can be enabled via APEN."]
92    A24 = 3,
93}
94impl From<ALB_A> for u8 {
95    #[inline(always)]
96    fn from(variant: ALB_A) -> Self {
97        variant as _
98    }
99}
100impl ALB_R {
101    #[doc = "Get enumerated values variant"]
102    #[inline(always)]
103    pub fn variant(&self) -> ALB_A {
104        match self.bits {
105            0 => ALB_A::A0,
106            1 => ALB_A::A8,
107            2 => ALB_A::A16,
108            3 => ALB_A::A24,
109            _ => unreachable!(),
110        }
111    }
112    #[doc = "Checks if the value of the field is `A0`"]
113    #[inline(always)]
114    pub fn is_a0(&self) -> bool {
115        *self == ALB_A::A0
116    }
117    #[doc = "Checks if the value of the field is `A8`"]
118    #[inline(always)]
119    pub fn is_a8(&self) -> bool {
120        *self == ALB_A::A8
121    }
122    #[doc = "Checks if the value of the field is `A16`"]
123    #[inline(always)]
124    pub fn is_a16(&self) -> bool {
125        *self == ALB_A::A16
126    }
127    #[doc = "Checks if the value of the field is `A24`"]
128    #[inline(always)]
129    pub fn is_a24(&self) -> bool {
130        *self == ALB_A::A24
131    }
132}
133#[doc = "Field `ALB` writer - Sets the lower bound for EBI_A enabling"]
134pub type ALB_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, ROUTE_SPEC, u8, ALB_A, 2, O>;
135impl<'a, const O: u8> ALB_W<'a, O> {
136    #[doc = "Address lines from EBI_A\\[0\\]
137and upwards can be enabled via APEN."]
138    #[inline(always)]
139    pub fn a0(self) -> &'a mut W {
140        self.variant(ALB_A::A0)
141    }
142    #[doc = "Address lines from EBI_A\\[8\\]
143and upwards can be enabled via APEN."]
144    #[inline(always)]
145    pub fn a8(self) -> &'a mut W {
146        self.variant(ALB_A::A8)
147    }
148    #[doc = "Address lines from EBI_A\\[16\\]
149and upwards can be enabled via APEN."]
150    #[inline(always)]
151    pub fn a16(self) -> &'a mut W {
152        self.variant(ALB_A::A16)
153    }
154    #[doc = "Address lines from EBI_A\\[24\\]
155and upwards can be enabled via APEN."]
156    #[inline(always)]
157    pub fn a24(self) -> &'a mut W {
158        self.variant(ALB_A::A24)
159    }
160}
161#[doc = "Field `APEN` reader - EBI_A Pin Enable"]
162pub type APEN_R = crate::FieldReader<u8, APEN_A>;
163#[doc = "EBI_A Pin Enable\n\nValue on reset: 0"]
164#[derive(Clone, Copy, Debug, PartialEq, Eq)]
165#[repr(u8)]
166pub enum APEN_A {
167    #[doc = "0: All EBI_A pins are disabled."]
168    A0 = 0,
169    #[doc = "5: EBI_A\\[4:L\\]
170pins enabled."]
171    A5 = 5,
172    #[doc = "6: EBI_A\\[5:L\\]
173pins enabled."]
174    A6 = 6,
175    #[doc = "7: EBI_A\\[6:L\\]
176pins enabled."]
177    A7 = 7,
178    #[doc = "8: EBI_A\\[7:L\\]
179pins enabled."]
180    A8 = 8,
181    #[doc = "9: EBI_A\\[8:L\\]
182pins enabled."]
183    A9 = 9,
184    #[doc = "10: EBI_A\\[9:L\\]
185pins enabled."]
186    A10 = 10,
187    #[doc = "11: EBI_A\\[10:L\\]
188pins enabled."]
189    A11 = 11,
190    #[doc = "12: EBI_A\\[11:L\\]
191pins enabled."]
192    A12 = 12,
193    #[doc = "13: EBI_A\\[12:L\\]
194pins enabled."]
195    A13 = 13,
196    #[doc = "14: EBI_A\\[13:L\\]
197pins enabled."]
198    A14 = 14,
199    #[doc = "15: EBI_A\\[14:L\\]
200pins enabled."]
201    A15 = 15,
202    #[doc = "16: EBI_A\\[15:L\\]
203pins enabled."]
204    A16 = 16,
205    #[doc = "17: EBI_A\\[16:L\\]
206pins enabled."]
207    A17 = 17,
208    #[doc = "18: EBI_A\\[17:L\\]
209pins enabled."]
210    A18 = 18,
211    #[doc = "19: EBI_A\\[18:L\\]
212pins enabled."]
213    A19 = 19,
214    #[doc = "20: EBI_A\\[19:L\\]
215pins enabled."]
216    A20 = 20,
217    #[doc = "21: EBI_A\\[20:L\\]
218pins enabled."]
219    A21 = 21,
220    #[doc = "22: EBI_A\\[21:L\\]
221pins enabled."]
222    A22 = 22,
223    #[doc = "23: EBI_A\\[22:L\\]
224pins enabled."]
225    A23 = 23,
226    #[doc = "24: EBI_A\\[23:L\\]
227pins enabled."]
228    A24 = 24,
229    #[doc = "25: EBI_A\\[24:L\\]
230pins enabled."]
231    A25 = 25,
232    #[doc = "26: EBI_A\\[25:L\\]
233pins enabled."]
234    A26 = 26,
235    #[doc = "27: EBI_A\\[26:L\\]
236pins enabled."]
237    A27 = 27,
238    #[doc = "28: EBI_A\\[27:L\\]
239pins enabled."]
240    A28 = 28,
241}
242impl From<APEN_A> for u8 {
243    #[inline(always)]
244    fn from(variant: APEN_A) -> Self {
245        variant as _
246    }
247}
248impl APEN_R {
249    #[doc = "Get enumerated values variant"]
250    #[inline(always)]
251    pub fn variant(&self) -> Option<APEN_A> {
252        match self.bits {
253            0 => Some(APEN_A::A0),
254            5 => Some(APEN_A::A5),
255            6 => Some(APEN_A::A6),
256            7 => Some(APEN_A::A7),
257            8 => Some(APEN_A::A8),
258            9 => Some(APEN_A::A9),
259            10 => Some(APEN_A::A10),
260            11 => Some(APEN_A::A11),
261            12 => Some(APEN_A::A12),
262            13 => Some(APEN_A::A13),
263            14 => Some(APEN_A::A14),
264            15 => Some(APEN_A::A15),
265            16 => Some(APEN_A::A16),
266            17 => Some(APEN_A::A17),
267            18 => Some(APEN_A::A18),
268            19 => Some(APEN_A::A19),
269            20 => Some(APEN_A::A20),
270            21 => Some(APEN_A::A21),
271            22 => Some(APEN_A::A22),
272            23 => Some(APEN_A::A23),
273            24 => Some(APEN_A::A24),
274            25 => Some(APEN_A::A25),
275            26 => Some(APEN_A::A26),
276            27 => Some(APEN_A::A27),
277            28 => Some(APEN_A::A28),
278            _ => None,
279        }
280    }
281    #[doc = "Checks if the value of the field is `A0`"]
282    #[inline(always)]
283    pub fn is_a0(&self) -> bool {
284        *self == APEN_A::A0
285    }
286    #[doc = "Checks if the value of the field is `A5`"]
287    #[inline(always)]
288    pub fn is_a5(&self) -> bool {
289        *self == APEN_A::A5
290    }
291    #[doc = "Checks if the value of the field is `A6`"]
292    #[inline(always)]
293    pub fn is_a6(&self) -> bool {
294        *self == APEN_A::A6
295    }
296    #[doc = "Checks if the value of the field is `A7`"]
297    #[inline(always)]
298    pub fn is_a7(&self) -> bool {
299        *self == APEN_A::A7
300    }
301    #[doc = "Checks if the value of the field is `A8`"]
302    #[inline(always)]
303    pub fn is_a8(&self) -> bool {
304        *self == APEN_A::A8
305    }
306    #[doc = "Checks if the value of the field is `A9`"]
307    #[inline(always)]
308    pub fn is_a9(&self) -> bool {
309        *self == APEN_A::A9
310    }
311    #[doc = "Checks if the value of the field is `A10`"]
312    #[inline(always)]
313    pub fn is_a10(&self) -> bool {
314        *self == APEN_A::A10
315    }
316    #[doc = "Checks if the value of the field is `A11`"]
317    #[inline(always)]
318    pub fn is_a11(&self) -> bool {
319        *self == APEN_A::A11
320    }
321    #[doc = "Checks if the value of the field is `A12`"]
322    #[inline(always)]
323    pub fn is_a12(&self) -> bool {
324        *self == APEN_A::A12
325    }
326    #[doc = "Checks if the value of the field is `A13`"]
327    #[inline(always)]
328    pub fn is_a13(&self) -> bool {
329        *self == APEN_A::A13
330    }
331    #[doc = "Checks if the value of the field is `A14`"]
332    #[inline(always)]
333    pub fn is_a14(&self) -> bool {
334        *self == APEN_A::A14
335    }
336    #[doc = "Checks if the value of the field is `A15`"]
337    #[inline(always)]
338    pub fn is_a15(&self) -> bool {
339        *self == APEN_A::A15
340    }
341    #[doc = "Checks if the value of the field is `A16`"]
342    #[inline(always)]
343    pub fn is_a16(&self) -> bool {
344        *self == APEN_A::A16
345    }
346    #[doc = "Checks if the value of the field is `A17`"]
347    #[inline(always)]
348    pub fn is_a17(&self) -> bool {
349        *self == APEN_A::A17
350    }
351    #[doc = "Checks if the value of the field is `A18`"]
352    #[inline(always)]
353    pub fn is_a18(&self) -> bool {
354        *self == APEN_A::A18
355    }
356    #[doc = "Checks if the value of the field is `A19`"]
357    #[inline(always)]
358    pub fn is_a19(&self) -> bool {
359        *self == APEN_A::A19
360    }
361    #[doc = "Checks if the value of the field is `A20`"]
362    #[inline(always)]
363    pub fn is_a20(&self) -> bool {
364        *self == APEN_A::A20
365    }
366    #[doc = "Checks if the value of the field is `A21`"]
367    #[inline(always)]
368    pub fn is_a21(&self) -> bool {
369        *self == APEN_A::A21
370    }
371    #[doc = "Checks if the value of the field is `A22`"]
372    #[inline(always)]
373    pub fn is_a22(&self) -> bool {
374        *self == APEN_A::A22
375    }
376    #[doc = "Checks if the value of the field is `A23`"]
377    #[inline(always)]
378    pub fn is_a23(&self) -> bool {
379        *self == APEN_A::A23
380    }
381    #[doc = "Checks if the value of the field is `A24`"]
382    #[inline(always)]
383    pub fn is_a24(&self) -> bool {
384        *self == APEN_A::A24
385    }
386    #[doc = "Checks if the value of the field is `A25`"]
387    #[inline(always)]
388    pub fn is_a25(&self) -> bool {
389        *self == APEN_A::A25
390    }
391    #[doc = "Checks if the value of the field is `A26`"]
392    #[inline(always)]
393    pub fn is_a26(&self) -> bool {
394        *self == APEN_A::A26
395    }
396    #[doc = "Checks if the value of the field is `A27`"]
397    #[inline(always)]
398    pub fn is_a27(&self) -> bool {
399        *self == APEN_A::A27
400    }
401    #[doc = "Checks if the value of the field is `A28`"]
402    #[inline(always)]
403    pub fn is_a28(&self) -> bool {
404        *self == APEN_A::A28
405    }
406}
407#[doc = "Field `APEN` writer - EBI_A Pin Enable"]
408pub type APEN_W<'a, const O: u8> = crate::FieldWriter<'a, u32, ROUTE_SPEC, u8, APEN_A, 5, O>;
409impl<'a, const O: u8> APEN_W<'a, O> {
410    #[doc = "All EBI_A pins are disabled."]
411    #[inline(always)]
412    pub fn a0(self) -> &'a mut W {
413        self.variant(APEN_A::A0)
414    }
415    #[doc = "EBI_A\\[4:L\\]
416pins enabled."]
417    #[inline(always)]
418    pub fn a5(self) -> &'a mut W {
419        self.variant(APEN_A::A5)
420    }
421    #[doc = "EBI_A\\[5:L\\]
422pins enabled."]
423    #[inline(always)]
424    pub fn a6(self) -> &'a mut W {
425        self.variant(APEN_A::A6)
426    }
427    #[doc = "EBI_A\\[6:L\\]
428pins enabled."]
429    #[inline(always)]
430    pub fn a7(self) -> &'a mut W {
431        self.variant(APEN_A::A7)
432    }
433    #[doc = "EBI_A\\[7:L\\]
434pins enabled."]
435    #[inline(always)]
436    pub fn a8(self) -> &'a mut W {
437        self.variant(APEN_A::A8)
438    }
439    #[doc = "EBI_A\\[8:L\\]
440pins enabled."]
441    #[inline(always)]
442    pub fn a9(self) -> &'a mut W {
443        self.variant(APEN_A::A9)
444    }
445    #[doc = "EBI_A\\[9:L\\]
446pins enabled."]
447    #[inline(always)]
448    pub fn a10(self) -> &'a mut W {
449        self.variant(APEN_A::A10)
450    }
451    #[doc = "EBI_A\\[10:L\\]
452pins enabled."]
453    #[inline(always)]
454    pub fn a11(self) -> &'a mut W {
455        self.variant(APEN_A::A11)
456    }
457    #[doc = "EBI_A\\[11:L\\]
458pins enabled."]
459    #[inline(always)]
460    pub fn a12(self) -> &'a mut W {
461        self.variant(APEN_A::A12)
462    }
463    #[doc = "EBI_A\\[12:L\\]
464pins enabled."]
465    #[inline(always)]
466    pub fn a13(self) -> &'a mut W {
467        self.variant(APEN_A::A13)
468    }
469    #[doc = "EBI_A\\[13:L\\]
470pins enabled."]
471    #[inline(always)]
472    pub fn a14(self) -> &'a mut W {
473        self.variant(APEN_A::A14)
474    }
475    #[doc = "EBI_A\\[14:L\\]
476pins enabled."]
477    #[inline(always)]
478    pub fn a15(self) -> &'a mut W {
479        self.variant(APEN_A::A15)
480    }
481    #[doc = "EBI_A\\[15:L\\]
482pins enabled."]
483    #[inline(always)]
484    pub fn a16(self) -> &'a mut W {
485        self.variant(APEN_A::A16)
486    }
487    #[doc = "EBI_A\\[16:L\\]
488pins enabled."]
489    #[inline(always)]
490    pub fn a17(self) -> &'a mut W {
491        self.variant(APEN_A::A17)
492    }
493    #[doc = "EBI_A\\[17:L\\]
494pins enabled."]
495    #[inline(always)]
496    pub fn a18(self) -> &'a mut W {
497        self.variant(APEN_A::A18)
498    }
499    #[doc = "EBI_A\\[18:L\\]
500pins enabled."]
501    #[inline(always)]
502    pub fn a19(self) -> &'a mut W {
503        self.variant(APEN_A::A19)
504    }
505    #[doc = "EBI_A\\[19:L\\]
506pins enabled."]
507    #[inline(always)]
508    pub fn a20(self) -> &'a mut W {
509        self.variant(APEN_A::A20)
510    }
511    #[doc = "EBI_A\\[20:L\\]
512pins enabled."]
513    #[inline(always)]
514    pub fn a21(self) -> &'a mut W {
515        self.variant(APEN_A::A21)
516    }
517    #[doc = "EBI_A\\[21:L\\]
518pins enabled."]
519    #[inline(always)]
520    pub fn a22(self) -> &'a mut W {
521        self.variant(APEN_A::A22)
522    }
523    #[doc = "EBI_A\\[22:L\\]
524pins enabled."]
525    #[inline(always)]
526    pub fn a23(self) -> &'a mut W {
527        self.variant(APEN_A::A23)
528    }
529    #[doc = "EBI_A\\[23:L\\]
530pins enabled."]
531    #[inline(always)]
532    pub fn a24(self) -> &'a mut W {
533        self.variant(APEN_A::A24)
534    }
535    #[doc = "EBI_A\\[24:L\\]
536pins enabled."]
537    #[inline(always)]
538    pub fn a25(self) -> &'a mut W {
539        self.variant(APEN_A::A25)
540    }
541    #[doc = "EBI_A\\[25:L\\]
542pins enabled."]
543    #[inline(always)]
544    pub fn a26(self) -> &'a mut W {
545        self.variant(APEN_A::A26)
546    }
547    #[doc = "EBI_A\\[26:L\\]
548pins enabled."]
549    #[inline(always)]
550    pub fn a27(self) -> &'a mut W {
551        self.variant(APEN_A::A27)
552    }
553    #[doc = "EBI_A\\[27:L\\]
554pins enabled."]
555    #[inline(always)]
556    pub fn a28(self) -> &'a mut W {
557        self.variant(APEN_A::A28)
558    }
559}
560#[doc = "Field `TFTPEN` reader - EBI_TFT Pin Enable"]
561pub type TFTPEN_R = crate::BitReader<bool>;
562#[doc = "Field `TFTPEN` writer - EBI_TFT Pin Enable"]
563pub type TFTPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
564#[doc = "Field `DATAENPEN` reader - EBI_TFT Pin Enable"]
565pub type DATAENPEN_R = crate::BitReader<bool>;
566#[doc = "Field `DATAENPEN` writer - EBI_TFT Pin Enable"]
567pub type DATAENPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
568#[doc = "Field `CSTFTPEN` reader - EBI_CSTFT Pin Enable"]
569pub type CSTFTPEN_R = crate::BitReader<bool>;
570#[doc = "Field `CSTFTPEN` writer - EBI_CSTFT Pin Enable"]
571pub type CSTFTPEN_W<'a, const O: u8> = crate::BitWriter<'a, u32, ROUTE_SPEC, bool, O>;
572#[doc = "Field `LOCATION` reader - I/O Location"]
573pub type LOCATION_R = crate::FieldReader<u8, LOCATION_A>;
574#[doc = "I/O Location\n\nValue on reset: 0"]
575#[derive(Clone, Copy, Debug, PartialEq, Eq)]
576#[repr(u8)]
577pub enum LOCATION_A {
578    #[doc = "0: Location 0"]
579    LOC0 = 0,
580    #[doc = "1: Location 1"]
581    LOC1 = 1,
582    #[doc = "2: Location 2"]
583    LOC2 = 2,
584}
585impl From<LOCATION_A> for u8 {
586    #[inline(always)]
587    fn from(variant: LOCATION_A) -> Self {
588        variant as _
589    }
590}
591impl LOCATION_R {
592    #[doc = "Get enumerated values variant"]
593    #[inline(always)]
594    pub fn variant(&self) -> Option<LOCATION_A> {
595        match self.bits {
596            0 => Some(LOCATION_A::LOC0),
597            1 => Some(LOCATION_A::LOC1),
598            2 => Some(LOCATION_A::LOC2),
599            _ => None,
600        }
601    }
602    #[doc = "Checks if the value of the field is `LOC0`"]
603    #[inline(always)]
604    pub fn is_loc0(&self) -> bool {
605        *self == LOCATION_A::LOC0
606    }
607    #[doc = "Checks if the value of the field is `LOC1`"]
608    #[inline(always)]
609    pub fn is_loc1(&self) -> bool {
610        *self == LOCATION_A::LOC1
611    }
612    #[doc = "Checks if the value of the field is `LOC2`"]
613    #[inline(always)]
614    pub fn is_loc2(&self) -> bool {
615        *self == LOCATION_A::LOC2
616    }
617}
618#[doc = "Field `LOCATION` writer - I/O Location"]
619pub type LOCATION_W<'a, const O: u8> =
620    crate::FieldWriter<'a, u32, ROUTE_SPEC, u8, LOCATION_A, 3, O>;
621impl<'a, const O: u8> LOCATION_W<'a, O> {
622    #[doc = "Location 0"]
623    #[inline(always)]
624    pub fn loc0(self) -> &'a mut W {
625        self.variant(LOCATION_A::LOC0)
626    }
627    #[doc = "Location 1"]
628    #[inline(always)]
629    pub fn loc1(self) -> &'a mut W {
630        self.variant(LOCATION_A::LOC1)
631    }
632    #[doc = "Location 2"]
633    #[inline(always)]
634    pub fn loc2(self) -> &'a mut W {
635        self.variant(LOCATION_A::LOC2)
636    }
637}
638impl R {
639    #[doc = "Bit 0 - EBI Pin Enable"]
640    #[inline(always)]
641    pub fn ebipen(&self) -> EBIPEN_R {
642        EBIPEN_R::new((self.bits & 1) != 0)
643    }
644    #[doc = "Bit 1 - EBI_CS0 Pin Enable"]
645    #[inline(always)]
646    pub fn cs0pen(&self) -> CS0PEN_R {
647        CS0PEN_R::new(((self.bits >> 1) & 1) != 0)
648    }
649    #[doc = "Bit 2 - EBI_CS1 Pin Enable"]
650    #[inline(always)]
651    pub fn cs1pen(&self) -> CS1PEN_R {
652        CS1PEN_R::new(((self.bits >> 2) & 1) != 0)
653    }
654    #[doc = "Bit 3 - EBI_CS2 Pin Enable"]
655    #[inline(always)]
656    pub fn cs2pen(&self) -> CS2PEN_R {
657        CS2PEN_R::new(((self.bits >> 3) & 1) != 0)
658    }
659    #[doc = "Bit 4 - EBI_CS3 Pin Enable"]
660    #[inline(always)]
661    pub fn cs3pen(&self) -> CS3PEN_R {
662        CS3PEN_R::new(((self.bits >> 4) & 1) != 0)
663    }
664    #[doc = "Bit 5 - EBI_ALE Pin Enable"]
665    #[inline(always)]
666    pub fn alepen(&self) -> ALEPEN_R {
667        ALEPEN_R::new(((self.bits >> 5) & 1) != 0)
668    }
669    #[doc = "Bit 6 - EBI_ARDY Pin Enable"]
670    #[inline(always)]
671    pub fn ardypen(&self) -> ARDYPEN_R {
672        ARDYPEN_R::new(((self.bits >> 6) & 1) != 0)
673    }
674    #[doc = "Bit 7 - EBI_BL\\[1:0\\]
675Pin Enable"]
676    #[inline(always)]
677    pub fn blpen(&self) -> BLPEN_R {
678        BLPEN_R::new(((self.bits >> 7) & 1) != 0)
679    }
680    #[doc = "Bit 12 - NANDRE and NANDWE Pin Enable"]
681    #[inline(always)]
682    pub fn nandpen(&self) -> NANDPEN_R {
683        NANDPEN_R::new(((self.bits >> 12) & 1) != 0)
684    }
685    #[doc = "Bits 16:17 - Sets the lower bound for EBI_A enabling"]
686    #[inline(always)]
687    pub fn alb(&self) -> ALB_R {
688        ALB_R::new(((self.bits >> 16) & 3) as u8)
689    }
690    #[doc = "Bits 18:22 - EBI_A Pin Enable"]
691    #[inline(always)]
692    pub fn apen(&self) -> APEN_R {
693        APEN_R::new(((self.bits >> 18) & 0x1f) as u8)
694    }
695    #[doc = "Bit 24 - EBI_TFT Pin Enable"]
696    #[inline(always)]
697    pub fn tftpen(&self) -> TFTPEN_R {
698        TFTPEN_R::new(((self.bits >> 24) & 1) != 0)
699    }
700    #[doc = "Bit 25 - EBI_TFT Pin Enable"]
701    #[inline(always)]
702    pub fn dataenpen(&self) -> DATAENPEN_R {
703        DATAENPEN_R::new(((self.bits >> 25) & 1) != 0)
704    }
705    #[doc = "Bit 26 - EBI_CSTFT Pin Enable"]
706    #[inline(always)]
707    pub fn cstftpen(&self) -> CSTFTPEN_R {
708        CSTFTPEN_R::new(((self.bits >> 26) & 1) != 0)
709    }
710    #[doc = "Bits 28:30 - I/O Location"]
711    #[inline(always)]
712    pub fn location(&self) -> LOCATION_R {
713        LOCATION_R::new(((self.bits >> 28) & 7) as u8)
714    }
715}
716impl W {
717    #[doc = "Bit 0 - EBI Pin Enable"]
718    #[inline(always)]
719    #[must_use]
720    pub fn ebipen(&mut self) -> EBIPEN_W<0> {
721        EBIPEN_W::new(self)
722    }
723    #[doc = "Bit 1 - EBI_CS0 Pin Enable"]
724    #[inline(always)]
725    #[must_use]
726    pub fn cs0pen(&mut self) -> CS0PEN_W<1> {
727        CS0PEN_W::new(self)
728    }
729    #[doc = "Bit 2 - EBI_CS1 Pin Enable"]
730    #[inline(always)]
731    #[must_use]
732    pub fn cs1pen(&mut self) -> CS1PEN_W<2> {
733        CS1PEN_W::new(self)
734    }
735    #[doc = "Bit 3 - EBI_CS2 Pin Enable"]
736    #[inline(always)]
737    #[must_use]
738    pub fn cs2pen(&mut self) -> CS2PEN_W<3> {
739        CS2PEN_W::new(self)
740    }
741    #[doc = "Bit 4 - EBI_CS3 Pin Enable"]
742    #[inline(always)]
743    #[must_use]
744    pub fn cs3pen(&mut self) -> CS3PEN_W<4> {
745        CS3PEN_W::new(self)
746    }
747    #[doc = "Bit 5 - EBI_ALE Pin Enable"]
748    #[inline(always)]
749    #[must_use]
750    pub fn alepen(&mut self) -> ALEPEN_W<5> {
751        ALEPEN_W::new(self)
752    }
753    #[doc = "Bit 6 - EBI_ARDY Pin Enable"]
754    #[inline(always)]
755    #[must_use]
756    pub fn ardypen(&mut self) -> ARDYPEN_W<6> {
757        ARDYPEN_W::new(self)
758    }
759    #[doc = "Bit 7 - EBI_BL\\[1:0\\]
760Pin Enable"]
761    #[inline(always)]
762    #[must_use]
763    pub fn blpen(&mut self) -> BLPEN_W<7> {
764        BLPEN_W::new(self)
765    }
766    #[doc = "Bit 12 - NANDRE and NANDWE Pin Enable"]
767    #[inline(always)]
768    #[must_use]
769    pub fn nandpen(&mut self) -> NANDPEN_W<12> {
770        NANDPEN_W::new(self)
771    }
772    #[doc = "Bits 16:17 - Sets the lower bound for EBI_A enabling"]
773    #[inline(always)]
774    #[must_use]
775    pub fn alb(&mut self) -> ALB_W<16> {
776        ALB_W::new(self)
777    }
778    #[doc = "Bits 18:22 - EBI_A Pin Enable"]
779    #[inline(always)]
780    #[must_use]
781    pub fn apen(&mut self) -> APEN_W<18> {
782        APEN_W::new(self)
783    }
784    #[doc = "Bit 24 - EBI_TFT Pin Enable"]
785    #[inline(always)]
786    #[must_use]
787    pub fn tftpen(&mut self) -> TFTPEN_W<24> {
788        TFTPEN_W::new(self)
789    }
790    #[doc = "Bit 25 - EBI_TFT Pin Enable"]
791    #[inline(always)]
792    #[must_use]
793    pub fn dataenpen(&mut self) -> DATAENPEN_W<25> {
794        DATAENPEN_W::new(self)
795    }
796    #[doc = "Bit 26 - EBI_CSTFT Pin Enable"]
797    #[inline(always)]
798    #[must_use]
799    pub fn cstftpen(&mut self) -> CSTFTPEN_W<26> {
800        CSTFTPEN_W::new(self)
801    }
802    #[doc = "Bits 28:30 - I/O Location"]
803    #[inline(always)]
804    #[must_use]
805    pub fn location(&mut self) -> LOCATION_W<28> {
806        LOCATION_W::new(self)
807    }
808    #[doc = "Writes raw bits to the register."]
809    #[inline(always)]
810    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
811        self.0.bits(bits);
812        self
813    }
814}
815#[doc = "I/O Routing 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 [route](index.html) module"]
816pub struct ROUTE_SPEC;
817impl crate::RegisterSpec for ROUTE_SPEC {
818    type Ux = u32;
819}
820#[doc = "`read()` method returns [route::R](R) reader structure"]
821impl crate::Readable for ROUTE_SPEC {
822    type Reader = R;
823}
824#[doc = "`write(|w| ..)` method takes [route::W](W) writer structure"]
825impl crate::Writable for ROUTE_SPEC {
826    type Writer = W;
827    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
828    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
829}
830#[doc = "`reset()` method sets ROUTE to value 0"]
831impl crate::Resettable for ROUTE_SPEC {
832    const RESET_VALUE: Self::Ux = 0;
833}
efm32gg_pac/efm32gg995/ebi/route.rs

efm32gg_pac/efm32gg995/ebi/
route.rs
