xmc4500/eth0_con/
eth0_con.rs

1#[doc = "Register `ETH0_CON` reader"]
2pub type R = crate::R<ETH0_CON_SPEC>;
3#[doc = "Register `ETH0_CON` writer"]
4pub type W = crate::W<ETH0_CON_SPEC>;
5#[doc = "MAC Receive Input 0\n\nValue on reset: 0"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u8)]
8pub enum RXD0_A {
9    #[doc = "0: Data input RXD0A is selected"]
10    VALUE1 = 0,
11    #[doc = "1: Data input RXD0B is selected"]
12    VALUE2 = 1,
13    #[doc = "2: Data input RXD0C is selected"]
14    VALUE3 = 2,
15    #[doc = "3: Data input RXD0D is selected"]
16    VALUE4 = 3,
17}
18impl From<RXD0_A> for u8 {
19    #[inline(always)]
20    fn from(variant: RXD0_A) -> Self {
21        variant as _
22    }
23}
24impl crate::FieldSpec for RXD0_A {
25    type Ux = u8;
26}
27impl crate::IsEnum for RXD0_A {}
28#[doc = "Field `RXD0` reader - MAC Receive Input 0"]
29pub type RXD0_R = crate::FieldReader<RXD0_A>;
30impl RXD0_R {
31    #[doc = "Get enumerated values variant"]
32    #[inline(always)]
33    pub const fn variant(&self) -> RXD0_A {
34        match self.bits {
35            0 => RXD0_A::VALUE1,
36            1 => RXD0_A::VALUE2,
37            2 => RXD0_A::VALUE3,
38            3 => RXD0_A::VALUE4,
39            _ => unreachable!(),
40        }
41    }
42    #[doc = "Data input RXD0A is selected"]
43    #[inline(always)]
44    pub fn is_value1(&self) -> bool {
45        *self == RXD0_A::VALUE1
46    }
47    #[doc = "Data input RXD0B is selected"]
48    #[inline(always)]
49    pub fn is_value2(&self) -> bool {
50        *self == RXD0_A::VALUE2
51    }
52    #[doc = "Data input RXD0C is selected"]
53    #[inline(always)]
54    pub fn is_value3(&self) -> bool {
55        *self == RXD0_A::VALUE3
56    }
57    #[doc = "Data input RXD0D is selected"]
58    #[inline(always)]
59    pub fn is_value4(&self) -> bool {
60        *self == RXD0_A::VALUE4
61    }
62}
63#[doc = "Field `RXD0` writer - MAC Receive Input 0"]
64pub type RXD0_W<'a, REG> = crate::FieldWriter<'a, REG, 2, RXD0_A, crate::Safe>;
65impl<'a, REG> RXD0_W<'a, REG>
66where
67    REG: crate::Writable + crate::RegisterSpec,
68    REG::Ux: From<u8>,
69{
70    #[doc = "Data input RXD0A is selected"]
71    #[inline(always)]
72    pub fn value1(self) -> &'a mut crate::W<REG> {
73        self.variant(RXD0_A::VALUE1)
74    }
75    #[doc = "Data input RXD0B is selected"]
76    #[inline(always)]
77    pub fn value2(self) -> &'a mut crate::W<REG> {
78        self.variant(RXD0_A::VALUE2)
79    }
80    #[doc = "Data input RXD0C is selected"]
81    #[inline(always)]
82    pub fn value3(self) -> &'a mut crate::W<REG> {
83        self.variant(RXD0_A::VALUE3)
84    }
85    #[doc = "Data input RXD0D is selected"]
86    #[inline(always)]
87    pub fn value4(self) -> &'a mut crate::W<REG> {
88        self.variant(RXD0_A::VALUE4)
89    }
90}
91#[doc = "MAC Receive Input 1\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq, Eq)]
93#[repr(u8)]
94pub enum RXD1_A {
95    #[doc = "0: Data input RXD1A is selected"]
96    VALUE1 = 0,
97    #[doc = "1: Data input RXD1B is selected"]
98    VALUE2 = 1,
99    #[doc = "2: Data input RXD1C is selected"]
100    VALUE3 = 2,
101    #[doc = "3: Data input RXD1D is selected"]
102    VALUE4 = 3,
103}
104impl From<RXD1_A> for u8 {
105    #[inline(always)]
106    fn from(variant: RXD1_A) -> Self {
107        variant as _
108    }
109}
110impl crate::FieldSpec for RXD1_A {
111    type Ux = u8;
112}
113impl crate::IsEnum for RXD1_A {}
114#[doc = "Field `RXD1` reader - MAC Receive Input 1"]
115pub type RXD1_R = crate::FieldReader<RXD1_A>;
116impl RXD1_R {
117    #[doc = "Get enumerated values variant"]
118    #[inline(always)]
119    pub const fn variant(&self) -> RXD1_A {
120        match self.bits {
121            0 => RXD1_A::VALUE1,
122            1 => RXD1_A::VALUE2,
123            2 => RXD1_A::VALUE3,
124            3 => RXD1_A::VALUE4,
125            _ => unreachable!(),
126        }
127    }
128    #[doc = "Data input RXD1A is selected"]
129    #[inline(always)]
130    pub fn is_value1(&self) -> bool {
131        *self == RXD1_A::VALUE1
132    }
133    #[doc = "Data input RXD1B is selected"]
134    #[inline(always)]
135    pub fn is_value2(&self) -> bool {
136        *self == RXD1_A::VALUE2
137    }
138    #[doc = "Data input RXD1C is selected"]
139    #[inline(always)]
140    pub fn is_value3(&self) -> bool {
141        *self == RXD1_A::VALUE3
142    }
143    #[doc = "Data input RXD1D is selected"]
144    #[inline(always)]
145    pub fn is_value4(&self) -> bool {
146        *self == RXD1_A::VALUE4
147    }
148}
149#[doc = "Field `RXD1` writer - MAC Receive Input 1"]
150pub type RXD1_W<'a, REG> = crate::FieldWriter<'a, REG, 2, RXD1_A, crate::Safe>;
151impl<'a, REG> RXD1_W<'a, REG>
152where
153    REG: crate::Writable + crate::RegisterSpec,
154    REG::Ux: From<u8>,
155{
156    #[doc = "Data input RXD1A is selected"]
157    #[inline(always)]
158    pub fn value1(self) -> &'a mut crate::W<REG> {
159        self.variant(RXD1_A::VALUE1)
160    }
161    #[doc = "Data input RXD1B is selected"]
162    #[inline(always)]
163    pub fn value2(self) -> &'a mut crate::W<REG> {
164        self.variant(RXD1_A::VALUE2)
165    }
166    #[doc = "Data input RXD1C is selected"]
167    #[inline(always)]
168    pub fn value3(self) -> &'a mut crate::W<REG> {
169        self.variant(RXD1_A::VALUE3)
170    }
171    #[doc = "Data input RXD1D is selected"]
172    #[inline(always)]
173    pub fn value4(self) -> &'a mut crate::W<REG> {
174        self.variant(RXD1_A::VALUE4)
175    }
176}
177#[doc = "MAC Receive Input 2\n\nValue on reset: 0"]
178#[derive(Clone, Copy, Debug, PartialEq, Eq)]
179#[repr(u8)]
180pub enum RXD2_A {
181    #[doc = "0: Data input RXD2A is selected"]
182    VALUE1 = 0,
183    #[doc = "1: Data input RXD2B is selected"]
184    VALUE2 = 1,
185    #[doc = "2: Data input RXD2C is selected"]
186    VALUE3 = 2,
187    #[doc = "3: Data input RXD2D is selected"]
188    VALUE4 = 3,
189}
190impl From<RXD2_A> for u8 {
191    #[inline(always)]
192    fn from(variant: RXD2_A) -> Self {
193        variant as _
194    }
195}
196impl crate::FieldSpec for RXD2_A {
197    type Ux = u8;
198}
199impl crate::IsEnum for RXD2_A {}
200#[doc = "Field `RXD2` reader - MAC Receive Input 2"]
201pub type RXD2_R = crate::FieldReader<RXD2_A>;
202impl RXD2_R {
203    #[doc = "Get enumerated values variant"]
204    #[inline(always)]
205    pub const fn variant(&self) -> RXD2_A {
206        match self.bits {
207            0 => RXD2_A::VALUE1,
208            1 => RXD2_A::VALUE2,
209            2 => RXD2_A::VALUE3,
210            3 => RXD2_A::VALUE4,
211            _ => unreachable!(),
212        }
213    }
214    #[doc = "Data input RXD2A is selected"]
215    #[inline(always)]
216    pub fn is_value1(&self) -> bool {
217        *self == RXD2_A::VALUE1
218    }
219    #[doc = "Data input RXD2B is selected"]
220    #[inline(always)]
221    pub fn is_value2(&self) -> bool {
222        *self == RXD2_A::VALUE2
223    }
224    #[doc = "Data input RXD2C is selected"]
225    #[inline(always)]
226    pub fn is_value3(&self) -> bool {
227        *self == RXD2_A::VALUE3
228    }
229    #[doc = "Data input RXD2D is selected"]
230    #[inline(always)]
231    pub fn is_value4(&self) -> bool {
232        *self == RXD2_A::VALUE4
233    }
234}
235#[doc = "Field `RXD2` writer - MAC Receive Input 2"]
236pub type RXD2_W<'a, REG> = crate::FieldWriter<'a, REG, 2, RXD2_A, crate::Safe>;
237impl<'a, REG> RXD2_W<'a, REG>
238where
239    REG: crate::Writable + crate::RegisterSpec,
240    REG::Ux: From<u8>,
241{
242    #[doc = "Data input RXD2A is selected"]
243    #[inline(always)]
244    pub fn value1(self) -> &'a mut crate::W<REG> {
245        self.variant(RXD2_A::VALUE1)
246    }
247    #[doc = "Data input RXD2B is selected"]
248    #[inline(always)]
249    pub fn value2(self) -> &'a mut crate::W<REG> {
250        self.variant(RXD2_A::VALUE2)
251    }
252    #[doc = "Data input RXD2C is selected"]
253    #[inline(always)]
254    pub fn value3(self) -> &'a mut crate::W<REG> {
255        self.variant(RXD2_A::VALUE3)
256    }
257    #[doc = "Data input RXD2D is selected"]
258    #[inline(always)]
259    pub fn value4(self) -> &'a mut crate::W<REG> {
260        self.variant(RXD2_A::VALUE4)
261    }
262}
263#[doc = "MAC Receive Input 3\n\nValue on reset: 0"]
264#[derive(Clone, Copy, Debug, PartialEq, Eq)]
265#[repr(u8)]
266pub enum RXD3_A {
267    #[doc = "0: Data input RXD3A is selected"]
268    VALUE1 = 0,
269    #[doc = "1: Data input RXD3B is selected"]
270    VALUE2 = 1,
271    #[doc = "2: Data input RXD3C is selected"]
272    VALUE3 = 2,
273    #[doc = "3: Data input RXD3D is selected"]
274    VALUE4 = 3,
275}
276impl From<RXD3_A> for u8 {
277    #[inline(always)]
278    fn from(variant: RXD3_A) -> Self {
279        variant as _
280    }
281}
282impl crate::FieldSpec for RXD3_A {
283    type Ux = u8;
284}
285impl crate::IsEnum for RXD3_A {}
286#[doc = "Field `RXD3` reader - MAC Receive Input 3"]
287pub type RXD3_R = crate::FieldReader<RXD3_A>;
288impl RXD3_R {
289    #[doc = "Get enumerated values variant"]
290    #[inline(always)]
291    pub const fn variant(&self) -> RXD3_A {
292        match self.bits {
293            0 => RXD3_A::VALUE1,
294            1 => RXD3_A::VALUE2,
295            2 => RXD3_A::VALUE3,
296            3 => RXD3_A::VALUE4,
297            _ => unreachable!(),
298        }
299    }
300    #[doc = "Data input RXD3A is selected"]
301    #[inline(always)]
302    pub fn is_value1(&self) -> bool {
303        *self == RXD3_A::VALUE1
304    }
305    #[doc = "Data input RXD3B is selected"]
306    #[inline(always)]
307    pub fn is_value2(&self) -> bool {
308        *self == RXD3_A::VALUE2
309    }
310    #[doc = "Data input RXD3C is selected"]
311    #[inline(always)]
312    pub fn is_value3(&self) -> bool {
313        *self == RXD3_A::VALUE3
314    }
315    #[doc = "Data input RXD3D is selected"]
316    #[inline(always)]
317    pub fn is_value4(&self) -> bool {
318        *self == RXD3_A::VALUE4
319    }
320}
321#[doc = "Field `RXD3` writer - MAC Receive Input 3"]
322pub type RXD3_W<'a, REG> = crate::FieldWriter<'a, REG, 2, RXD3_A, crate::Safe>;
323impl<'a, REG> RXD3_W<'a, REG>
324where
325    REG: crate::Writable + crate::RegisterSpec,
326    REG::Ux: From<u8>,
327{
328    #[doc = "Data input RXD3A is selected"]
329    #[inline(always)]
330    pub fn value1(self) -> &'a mut crate::W<REG> {
331        self.variant(RXD3_A::VALUE1)
332    }
333    #[doc = "Data input RXD3B is selected"]
334    #[inline(always)]
335    pub fn value2(self) -> &'a mut crate::W<REG> {
336        self.variant(RXD3_A::VALUE2)
337    }
338    #[doc = "Data input RXD3C is selected"]
339    #[inline(always)]
340    pub fn value3(self) -> &'a mut crate::W<REG> {
341        self.variant(RXD3_A::VALUE3)
342    }
343    #[doc = "Data input RXD3D is selected"]
344    #[inline(always)]
345    pub fn value4(self) -> &'a mut crate::W<REG> {
346        self.variant(RXD3_A::VALUE4)
347    }
348}
349#[doc = "RMII clock input\n\nValue on reset: 0"]
350#[derive(Clone, Copy, Debug, PartialEq, Eq)]
351#[repr(u8)]
352pub enum CLK_RMII_A {
353    #[doc = "0: Data input RMIIA is selected"]
354    VALUE1 = 0,
355    #[doc = "1: Data input RMIIB is selected"]
356    VALUE2 = 1,
357    #[doc = "2: Data input RMIIC is selected"]
358    VALUE3 = 2,
359    #[doc = "3: Data input RMIID is selected"]
360    VALUE4 = 3,
361}
362impl From<CLK_RMII_A> for u8 {
363    #[inline(always)]
364    fn from(variant: CLK_RMII_A) -> Self {
365        variant as _
366    }
367}
368impl crate::FieldSpec for CLK_RMII_A {
369    type Ux = u8;
370}
371impl crate::IsEnum for CLK_RMII_A {}
372#[doc = "Field `CLK_RMII` reader - RMII clock input"]
373pub type CLK_RMII_R = crate::FieldReader<CLK_RMII_A>;
374impl CLK_RMII_R {
375    #[doc = "Get enumerated values variant"]
376    #[inline(always)]
377    pub const fn variant(&self) -> CLK_RMII_A {
378        match self.bits {
379            0 => CLK_RMII_A::VALUE1,
380            1 => CLK_RMII_A::VALUE2,
381            2 => CLK_RMII_A::VALUE3,
382            3 => CLK_RMII_A::VALUE4,
383            _ => unreachable!(),
384        }
385    }
386    #[doc = "Data input RMIIA is selected"]
387    #[inline(always)]
388    pub fn is_value1(&self) -> bool {
389        *self == CLK_RMII_A::VALUE1
390    }
391    #[doc = "Data input RMIIB is selected"]
392    #[inline(always)]
393    pub fn is_value2(&self) -> bool {
394        *self == CLK_RMII_A::VALUE2
395    }
396    #[doc = "Data input RMIIC is selected"]
397    #[inline(always)]
398    pub fn is_value3(&self) -> bool {
399        *self == CLK_RMII_A::VALUE3
400    }
401    #[doc = "Data input RMIID is selected"]
402    #[inline(always)]
403    pub fn is_value4(&self) -> bool {
404        *self == CLK_RMII_A::VALUE4
405    }
406}
407#[doc = "Field `CLK_RMII` writer - RMII clock input"]
408pub type CLK_RMII_W<'a, REG> = crate::FieldWriter<'a, REG, 2, CLK_RMII_A, crate::Safe>;
409impl<'a, REG> CLK_RMII_W<'a, REG>
410where
411    REG: crate::Writable + crate::RegisterSpec,
412    REG::Ux: From<u8>,
413{
414    #[doc = "Data input RMIIA is selected"]
415    #[inline(always)]
416    pub fn value1(self) -> &'a mut crate::W<REG> {
417        self.variant(CLK_RMII_A::VALUE1)
418    }
419    #[doc = "Data input RMIIB is selected"]
420    #[inline(always)]
421    pub fn value2(self) -> &'a mut crate::W<REG> {
422        self.variant(CLK_RMII_A::VALUE2)
423    }
424    #[doc = "Data input RMIIC is selected"]
425    #[inline(always)]
426    pub fn value3(self) -> &'a mut crate::W<REG> {
427        self.variant(CLK_RMII_A::VALUE3)
428    }
429    #[doc = "Data input RMIID is selected"]
430    #[inline(always)]
431    pub fn value4(self) -> &'a mut crate::W<REG> {
432        self.variant(CLK_RMII_A::VALUE4)
433    }
434}
435#[doc = "CRS_DV input\n\nValue on reset: 0"]
436#[derive(Clone, Copy, Debug, PartialEq, Eq)]
437#[repr(u8)]
438pub enum CRS_DV_A {
439    #[doc = "0: Data input CRS_DVA is selected"]
440    VALUE1 = 0,
441    #[doc = "1: Data input CRS_DVB is selected"]
442    VALUE2 = 1,
443    #[doc = "2: Data input CRS_DVC is selected"]
444    VALUE3 = 2,
445    #[doc = "3: Data input CRS_DVD is selected"]
446    VALUE4 = 3,
447}
448impl From<CRS_DV_A> for u8 {
449    #[inline(always)]
450    fn from(variant: CRS_DV_A) -> Self {
451        variant as _
452    }
453}
454impl crate::FieldSpec for CRS_DV_A {
455    type Ux = u8;
456}
457impl crate::IsEnum for CRS_DV_A {}
458#[doc = "Field `CRS_DV` reader - CRS_DV input"]
459pub type CRS_DV_R = crate::FieldReader<CRS_DV_A>;
460impl CRS_DV_R {
461    #[doc = "Get enumerated values variant"]
462    #[inline(always)]
463    pub const fn variant(&self) -> CRS_DV_A {
464        match self.bits {
465            0 => CRS_DV_A::VALUE1,
466            1 => CRS_DV_A::VALUE2,
467            2 => CRS_DV_A::VALUE3,
468            3 => CRS_DV_A::VALUE4,
469            _ => unreachable!(),
470        }
471    }
472    #[doc = "Data input CRS_DVA is selected"]
473    #[inline(always)]
474    pub fn is_value1(&self) -> bool {
475        *self == CRS_DV_A::VALUE1
476    }
477    #[doc = "Data input CRS_DVB is selected"]
478    #[inline(always)]
479    pub fn is_value2(&self) -> bool {
480        *self == CRS_DV_A::VALUE2
481    }
482    #[doc = "Data input CRS_DVC is selected"]
483    #[inline(always)]
484    pub fn is_value3(&self) -> bool {
485        *self == CRS_DV_A::VALUE3
486    }
487    #[doc = "Data input CRS_DVD is selected"]
488    #[inline(always)]
489    pub fn is_value4(&self) -> bool {
490        *self == CRS_DV_A::VALUE4
491    }
492}
493#[doc = "Field `CRS_DV` writer - CRS_DV input"]
494pub type CRS_DV_W<'a, REG> = crate::FieldWriter<'a, REG, 2, CRS_DV_A, crate::Safe>;
495impl<'a, REG> CRS_DV_W<'a, REG>
496where
497    REG: crate::Writable + crate::RegisterSpec,
498    REG::Ux: From<u8>,
499{
500    #[doc = "Data input CRS_DVA is selected"]
501    #[inline(always)]
502    pub fn value1(self) -> &'a mut crate::W<REG> {
503        self.variant(CRS_DV_A::VALUE1)
504    }
505    #[doc = "Data input CRS_DVB is selected"]
506    #[inline(always)]
507    pub fn value2(self) -> &'a mut crate::W<REG> {
508        self.variant(CRS_DV_A::VALUE2)
509    }
510    #[doc = "Data input CRS_DVC is selected"]
511    #[inline(always)]
512    pub fn value3(self) -> &'a mut crate::W<REG> {
513        self.variant(CRS_DV_A::VALUE3)
514    }
515    #[doc = "Data input CRS_DVD is selected"]
516    #[inline(always)]
517    pub fn value4(self) -> &'a mut crate::W<REG> {
518        self.variant(CRS_DV_A::VALUE4)
519    }
520}
521#[doc = "CRS input\n\nValue on reset: 0"]
522#[derive(Clone, Copy, Debug, PartialEq, Eq)]
523#[repr(u8)]
524pub enum CRS_A {
525    #[doc = "0: Data input CRSA"]
526    VALUE1 = 0,
527    #[doc = "1: Data input CRSB"]
528    VALUE2 = 1,
529    #[doc = "2: Data input CRSC"]
530    VALUE3 = 2,
531    #[doc = "3: Data input CRSD"]
532    VALUE4 = 3,
533}
534impl From<CRS_A> for u8 {
535    #[inline(always)]
536    fn from(variant: CRS_A) -> Self {
537        variant as _
538    }
539}
540impl crate::FieldSpec for CRS_A {
541    type Ux = u8;
542}
543impl crate::IsEnum for CRS_A {}
544#[doc = "Field `CRS` reader - CRS input"]
545pub type CRS_R = crate::FieldReader<CRS_A>;
546impl CRS_R {
547    #[doc = "Get enumerated values variant"]
548    #[inline(always)]
549    pub const fn variant(&self) -> CRS_A {
550        match self.bits {
551            0 => CRS_A::VALUE1,
552            1 => CRS_A::VALUE2,
553            2 => CRS_A::VALUE3,
554            3 => CRS_A::VALUE4,
555            _ => unreachable!(),
556        }
557    }
558    #[doc = "Data input CRSA"]
559    #[inline(always)]
560    pub fn is_value1(&self) -> bool {
561        *self == CRS_A::VALUE1
562    }
563    #[doc = "Data input CRSB"]
564    #[inline(always)]
565    pub fn is_value2(&self) -> bool {
566        *self == CRS_A::VALUE2
567    }
568    #[doc = "Data input CRSC"]
569    #[inline(always)]
570    pub fn is_value3(&self) -> bool {
571        *self == CRS_A::VALUE3
572    }
573    #[doc = "Data input CRSD"]
574    #[inline(always)]
575    pub fn is_value4(&self) -> bool {
576        *self == CRS_A::VALUE4
577    }
578}
579#[doc = "Field `CRS` writer - CRS input"]
580pub type CRS_W<'a, REG> = crate::FieldWriter<'a, REG, 2, CRS_A, crate::Safe>;
581impl<'a, REG> CRS_W<'a, REG>
582where
583    REG: crate::Writable + crate::RegisterSpec,
584    REG::Ux: From<u8>,
585{
586    #[doc = "Data input CRSA"]
587    #[inline(always)]
588    pub fn value1(self) -> &'a mut crate::W<REG> {
589        self.variant(CRS_A::VALUE1)
590    }
591    #[doc = "Data input CRSB"]
592    #[inline(always)]
593    pub fn value2(self) -> &'a mut crate::W<REG> {
594        self.variant(CRS_A::VALUE2)
595    }
596    #[doc = "Data input CRSC"]
597    #[inline(always)]
598    pub fn value3(self) -> &'a mut crate::W<REG> {
599        self.variant(CRS_A::VALUE3)
600    }
601    #[doc = "Data input CRSD"]
602    #[inline(always)]
603    pub fn value4(self) -> &'a mut crate::W<REG> {
604        self.variant(CRS_A::VALUE4)
605    }
606}
607#[doc = "RXER Input\n\nValue on reset: 0"]
608#[derive(Clone, Copy, Debug, PartialEq, Eq)]
609#[repr(u8)]
610pub enum RXER_A {
611    #[doc = "0: Data input RXERA is selected"]
612    VALUE1 = 0,
613    #[doc = "1: Data input RXERB is selected"]
614    VALUE2 = 1,
615    #[doc = "2: Data input RXERC is selected"]
616    VALUE3 = 2,
617    #[doc = "3: Data input RXERD is selected"]
618    VALUE4 = 3,
619}
620impl From<RXER_A> for u8 {
621    #[inline(always)]
622    fn from(variant: RXER_A) -> Self {
623        variant as _
624    }
625}
626impl crate::FieldSpec for RXER_A {
627    type Ux = u8;
628}
629impl crate::IsEnum for RXER_A {}
630#[doc = "Field `RXER` reader - RXER Input"]
631pub type RXER_R = crate::FieldReader<RXER_A>;
632impl RXER_R {
633    #[doc = "Get enumerated values variant"]
634    #[inline(always)]
635    pub const fn variant(&self) -> RXER_A {
636        match self.bits {
637            0 => RXER_A::VALUE1,
638            1 => RXER_A::VALUE2,
639            2 => RXER_A::VALUE3,
640            3 => RXER_A::VALUE4,
641            _ => unreachable!(),
642        }
643    }
644    #[doc = "Data input RXERA is selected"]
645    #[inline(always)]
646    pub fn is_value1(&self) -> bool {
647        *self == RXER_A::VALUE1
648    }
649    #[doc = "Data input RXERB is selected"]
650    #[inline(always)]
651    pub fn is_value2(&self) -> bool {
652        *self == RXER_A::VALUE2
653    }
654    #[doc = "Data input RXERC is selected"]
655    #[inline(always)]
656    pub fn is_value3(&self) -> bool {
657        *self == RXER_A::VALUE3
658    }
659    #[doc = "Data input RXERD is selected"]
660    #[inline(always)]
661    pub fn is_value4(&self) -> bool {
662        *self == RXER_A::VALUE4
663    }
664}
665#[doc = "Field `RXER` writer - RXER Input"]
666pub type RXER_W<'a, REG> = crate::FieldWriter<'a, REG, 2, RXER_A, crate::Safe>;
667impl<'a, REG> RXER_W<'a, REG>
668where
669    REG: crate::Writable + crate::RegisterSpec,
670    REG::Ux: From<u8>,
671{
672    #[doc = "Data input RXERA is selected"]
673    #[inline(always)]
674    pub fn value1(self) -> &'a mut crate::W<REG> {
675        self.variant(RXER_A::VALUE1)
676    }
677    #[doc = "Data input RXERB is selected"]
678    #[inline(always)]
679    pub fn value2(self) -> &'a mut crate::W<REG> {
680        self.variant(RXER_A::VALUE2)
681    }
682    #[doc = "Data input RXERC is selected"]
683    #[inline(always)]
684    pub fn value3(self) -> &'a mut crate::W<REG> {
685        self.variant(RXER_A::VALUE3)
686    }
687    #[doc = "Data input RXERD is selected"]
688    #[inline(always)]
689    pub fn value4(self) -> &'a mut crate::W<REG> {
690        self.variant(RXER_A::VALUE4)
691    }
692}
693#[doc = "COL input\n\nValue on reset: 0"]
694#[derive(Clone, Copy, Debug, PartialEq, Eq)]
695#[repr(u8)]
696pub enum COL_A {
697    #[doc = "0: Data input COLA is selected"]
698    VALUE1 = 0,
699    #[doc = "1: Data input COLB is selected"]
700    VALUE2 = 1,
701    #[doc = "2: Data input COLC is selected"]
702    VALUE3 = 2,
703    #[doc = "3: Data input COLD is selected"]
704    VALUE4 = 3,
705}
706impl From<COL_A> for u8 {
707    #[inline(always)]
708    fn from(variant: COL_A) -> Self {
709        variant as _
710    }
711}
712impl crate::FieldSpec for COL_A {
713    type Ux = u8;
714}
715impl crate::IsEnum for COL_A {}
716#[doc = "Field `COL` reader - COL input"]
717pub type COL_R = crate::FieldReader<COL_A>;
718impl COL_R {
719    #[doc = "Get enumerated values variant"]
720    #[inline(always)]
721    pub const fn variant(&self) -> COL_A {
722        match self.bits {
723            0 => COL_A::VALUE1,
724            1 => COL_A::VALUE2,
725            2 => COL_A::VALUE3,
726            3 => COL_A::VALUE4,
727            _ => unreachable!(),
728        }
729    }
730    #[doc = "Data input COLA is selected"]
731    #[inline(always)]
732    pub fn is_value1(&self) -> bool {
733        *self == COL_A::VALUE1
734    }
735    #[doc = "Data input COLB is selected"]
736    #[inline(always)]
737    pub fn is_value2(&self) -> bool {
738        *self == COL_A::VALUE2
739    }
740    #[doc = "Data input COLC is selected"]
741    #[inline(always)]
742    pub fn is_value3(&self) -> bool {
743        *self == COL_A::VALUE3
744    }
745    #[doc = "Data input COLD is selected"]
746    #[inline(always)]
747    pub fn is_value4(&self) -> bool {
748        *self == COL_A::VALUE4
749    }
750}
751#[doc = "Field `COL` writer - COL input"]
752pub type COL_W<'a, REG> = crate::FieldWriter<'a, REG, 2, COL_A, crate::Safe>;
753impl<'a, REG> COL_W<'a, REG>
754where
755    REG: crate::Writable + crate::RegisterSpec,
756    REG::Ux: From<u8>,
757{
758    #[doc = "Data input COLA is selected"]
759    #[inline(always)]
760    pub fn value1(self) -> &'a mut crate::W<REG> {
761        self.variant(COL_A::VALUE1)
762    }
763    #[doc = "Data input COLB is selected"]
764    #[inline(always)]
765    pub fn value2(self) -> &'a mut crate::W<REG> {
766        self.variant(COL_A::VALUE2)
767    }
768    #[doc = "Data input COLC is selected"]
769    #[inline(always)]
770    pub fn value3(self) -> &'a mut crate::W<REG> {
771        self.variant(COL_A::VALUE3)
772    }
773    #[doc = "Data input COLD is selected"]
774    #[inline(always)]
775    pub fn value4(self) -> &'a mut crate::W<REG> {
776        self.variant(COL_A::VALUE4)
777    }
778}
779#[doc = "CLK_TX input\n\nValue on reset: 0"]
780#[derive(Clone, Copy, Debug, PartialEq, Eq)]
781#[repr(u8)]
782pub enum CLK_TX_A {
783    #[doc = "0: Data input CLK_TXA is selected"]
784    VALUE1 = 0,
785    #[doc = "1: Data input CLK_TXB is selected"]
786    VALUE2 = 1,
787    #[doc = "2: Data input CLK_TXC is selected"]
788    VALUE3 = 2,
789    #[doc = "3: Data input CLK_TXD is selected"]
790    VALUE4 = 3,
791}
792impl From<CLK_TX_A> for u8 {
793    #[inline(always)]
794    fn from(variant: CLK_TX_A) -> Self {
795        variant as _
796    }
797}
798impl crate::FieldSpec for CLK_TX_A {
799    type Ux = u8;
800}
801impl crate::IsEnum for CLK_TX_A {}
802#[doc = "Field `CLK_TX` reader - CLK_TX input"]
803pub type CLK_TX_R = crate::FieldReader<CLK_TX_A>;
804impl CLK_TX_R {
805    #[doc = "Get enumerated values variant"]
806    #[inline(always)]
807    pub const fn variant(&self) -> CLK_TX_A {
808        match self.bits {
809            0 => CLK_TX_A::VALUE1,
810            1 => CLK_TX_A::VALUE2,
811            2 => CLK_TX_A::VALUE3,
812            3 => CLK_TX_A::VALUE4,
813            _ => unreachable!(),
814        }
815    }
816    #[doc = "Data input CLK_TXA is selected"]
817    #[inline(always)]
818    pub fn is_value1(&self) -> bool {
819        *self == CLK_TX_A::VALUE1
820    }
821    #[doc = "Data input CLK_TXB is selected"]
822    #[inline(always)]
823    pub fn is_value2(&self) -> bool {
824        *self == CLK_TX_A::VALUE2
825    }
826    #[doc = "Data input CLK_TXC is selected"]
827    #[inline(always)]
828    pub fn is_value3(&self) -> bool {
829        *self == CLK_TX_A::VALUE3
830    }
831    #[doc = "Data input CLK_TXD is selected"]
832    #[inline(always)]
833    pub fn is_value4(&self) -> bool {
834        *self == CLK_TX_A::VALUE4
835    }
836}
837#[doc = "Field `CLK_TX` writer - CLK_TX input"]
838pub type CLK_TX_W<'a, REG> = crate::FieldWriter<'a, REG, 2, CLK_TX_A, crate::Safe>;
839impl<'a, REG> CLK_TX_W<'a, REG>
840where
841    REG: crate::Writable + crate::RegisterSpec,
842    REG::Ux: From<u8>,
843{
844    #[doc = "Data input CLK_TXA is selected"]
845    #[inline(always)]
846    pub fn value1(self) -> &'a mut crate::W<REG> {
847        self.variant(CLK_TX_A::VALUE1)
848    }
849    #[doc = "Data input CLK_TXB is selected"]
850    #[inline(always)]
851    pub fn value2(self) -> &'a mut crate::W<REG> {
852        self.variant(CLK_TX_A::VALUE2)
853    }
854    #[doc = "Data input CLK_TXC is selected"]
855    #[inline(always)]
856    pub fn value3(self) -> &'a mut crate::W<REG> {
857        self.variant(CLK_TX_A::VALUE3)
858    }
859    #[doc = "Data input CLK_TXD is selected"]
860    #[inline(always)]
861    pub fn value4(self) -> &'a mut crate::W<REG> {
862        self.variant(CLK_TX_A::VALUE4)
863    }
864}
865#[doc = "MDIO Input Select\n\nValue on reset: 0"]
866#[derive(Clone, Copy, Debug, PartialEq, Eq)]
867#[repr(u8)]
868pub enum MDIO_A {
869    #[doc = "0: Data input MDIA is selected"]
870    VALUE1 = 0,
871    #[doc = "1: Data input MDIB is selected"]
872    VALUE2 = 1,
873    #[doc = "2: Data input MDIC is selected"]
874    VALUE3 = 2,
875    #[doc = "3: Data input MDID is selected"]
876    VALUE4 = 3,
877}
878impl From<MDIO_A> for u8 {
879    #[inline(always)]
880    fn from(variant: MDIO_A) -> Self {
881        variant as _
882    }
883}
884impl crate::FieldSpec for MDIO_A {
885    type Ux = u8;
886}
887impl crate::IsEnum for MDIO_A {}
888#[doc = "Field `MDIO` reader - MDIO Input Select"]
889pub type MDIO_R = crate::FieldReader<MDIO_A>;
890impl MDIO_R {
891    #[doc = "Get enumerated values variant"]
892    #[inline(always)]
893    pub const fn variant(&self) -> MDIO_A {
894        match self.bits {
895            0 => MDIO_A::VALUE1,
896            1 => MDIO_A::VALUE2,
897            2 => MDIO_A::VALUE3,
898            3 => MDIO_A::VALUE4,
899            _ => unreachable!(),
900        }
901    }
902    #[doc = "Data input MDIA is selected"]
903    #[inline(always)]
904    pub fn is_value1(&self) -> bool {
905        *self == MDIO_A::VALUE1
906    }
907    #[doc = "Data input MDIB is selected"]
908    #[inline(always)]
909    pub fn is_value2(&self) -> bool {
910        *self == MDIO_A::VALUE2
911    }
912    #[doc = "Data input MDIC is selected"]
913    #[inline(always)]
914    pub fn is_value3(&self) -> bool {
915        *self == MDIO_A::VALUE3
916    }
917    #[doc = "Data input MDID is selected"]
918    #[inline(always)]
919    pub fn is_value4(&self) -> bool {
920        *self == MDIO_A::VALUE4
921    }
922}
923#[doc = "Field `MDIO` writer - MDIO Input Select"]
924pub type MDIO_W<'a, REG> = crate::FieldWriter<'a, REG, 2, MDIO_A, crate::Safe>;
925impl<'a, REG> MDIO_W<'a, REG>
926where
927    REG: crate::Writable + crate::RegisterSpec,
928    REG::Ux: From<u8>,
929{
930    #[doc = "Data input MDIA is selected"]
931    #[inline(always)]
932    pub fn value1(self) -> &'a mut crate::W<REG> {
933        self.variant(MDIO_A::VALUE1)
934    }
935    #[doc = "Data input MDIB is selected"]
936    #[inline(always)]
937    pub fn value2(self) -> &'a mut crate::W<REG> {
938        self.variant(MDIO_A::VALUE2)
939    }
940    #[doc = "Data input MDIC is selected"]
941    #[inline(always)]
942    pub fn value3(self) -> &'a mut crate::W<REG> {
943        self.variant(MDIO_A::VALUE3)
944    }
945    #[doc = "Data input MDID is selected"]
946    #[inline(always)]
947    pub fn value4(self) -> &'a mut crate::W<REG> {
948        self.variant(MDIO_A::VALUE4)
949    }
950}
951#[doc = "Ethernet MAC Interface Selection\n\nValue on reset: 0"]
952#[derive(Clone, Copy, Debug, PartialEq, Eq)]
953pub enum INFSEL_A {
954    #[doc = "0: MII"]
955    VALUE1 = 0,
956    #[doc = "1: RMII"]
957    VALUE2 = 1,
958}
959impl From<INFSEL_A> for bool {
960    #[inline(always)]
961    fn from(variant: INFSEL_A) -> Self {
962        variant as u8 != 0
963    }
964}
965#[doc = "Field `INFSEL` reader - Ethernet MAC Interface Selection"]
966pub type INFSEL_R = crate::BitReader<INFSEL_A>;
967impl INFSEL_R {
968    #[doc = "Get enumerated values variant"]
969    #[inline(always)]
970    pub const fn variant(&self) -> INFSEL_A {
971        match self.bits {
972            false => INFSEL_A::VALUE1,
973            true => INFSEL_A::VALUE2,
974        }
975    }
976    #[doc = "MII"]
977    #[inline(always)]
978    pub fn is_value1(&self) -> bool {
979        *self == INFSEL_A::VALUE1
980    }
981    #[doc = "RMII"]
982    #[inline(always)]
983    pub fn is_value2(&self) -> bool {
984        *self == INFSEL_A::VALUE2
985    }
986}
987#[doc = "Field `INFSEL` writer - Ethernet MAC Interface Selection"]
988pub type INFSEL_W<'a, REG> = crate::BitWriter<'a, REG, INFSEL_A>;
989impl<'a, REG> INFSEL_W<'a, REG>
990where
991    REG: crate::Writable + crate::RegisterSpec,
992{
993    #[doc = "MII"]
994    #[inline(always)]
995    pub fn value1(self) -> &'a mut crate::W<REG> {
996        self.variant(INFSEL_A::VALUE1)
997    }
998    #[doc = "RMII"]
999    #[inline(always)]
1000    pub fn value2(self) -> &'a mut crate::W<REG> {
1001        self.variant(INFSEL_A::VALUE2)
1002    }
1003}
1004impl R {
1005    #[doc = "Bits 0:1 - MAC Receive Input 0"]
1006    #[inline(always)]
1007    pub fn rxd0(&self) -> RXD0_R {
1008        RXD0_R::new((self.bits & 3) as u8)
1009    }
1010    #[doc = "Bits 2:3 - MAC Receive Input 1"]
1011    #[inline(always)]
1012    pub fn rxd1(&self) -> RXD1_R {
1013        RXD1_R::new(((self.bits >> 2) & 3) as u8)
1014    }
1015    #[doc = "Bits 4:5 - MAC Receive Input 2"]
1016    #[inline(always)]
1017    pub fn rxd2(&self) -> RXD2_R {
1018        RXD2_R::new(((self.bits >> 4) & 3) as u8)
1019    }
1020    #[doc = "Bits 6:7 - MAC Receive Input 3"]
1021    #[inline(always)]
1022    pub fn rxd3(&self) -> RXD3_R {
1023        RXD3_R::new(((self.bits >> 6) & 3) as u8)
1024    }
1025    #[doc = "Bits 8:9 - RMII clock input"]
1026    #[inline(always)]
1027    pub fn clk_rmii(&self) -> CLK_RMII_R {
1028        CLK_RMII_R::new(((self.bits >> 8) & 3) as u8)
1029    }
1030    #[doc = "Bits 10:11 - CRS_DV input"]
1031    #[inline(always)]
1032    pub fn crs_dv(&self) -> CRS_DV_R {
1033        CRS_DV_R::new(((self.bits >> 10) & 3) as u8)
1034    }
1035    #[doc = "Bits 12:13 - CRS input"]
1036    #[inline(always)]
1037    pub fn crs(&self) -> CRS_R {
1038        CRS_R::new(((self.bits >> 12) & 3) as u8)
1039    }
1040    #[doc = "Bits 14:15 - RXER Input"]
1041    #[inline(always)]
1042    pub fn rxer(&self) -> RXER_R {
1043        RXER_R::new(((self.bits >> 14) & 3) as u8)
1044    }
1045    #[doc = "Bits 16:17 - COL input"]
1046    #[inline(always)]
1047    pub fn col(&self) -> COL_R {
1048        COL_R::new(((self.bits >> 16) & 3) as u8)
1049    }
1050    #[doc = "Bits 18:19 - CLK_TX input"]
1051    #[inline(always)]
1052    pub fn clk_tx(&self) -> CLK_TX_R {
1053        CLK_TX_R::new(((self.bits >> 18) & 3) as u8)
1054    }
1055    #[doc = "Bits 22:23 - MDIO Input Select"]
1056    #[inline(always)]
1057    pub fn mdio(&self) -> MDIO_R {
1058        MDIO_R::new(((self.bits >> 22) & 3) as u8)
1059    }
1060    #[doc = "Bit 26 - Ethernet MAC Interface Selection"]
1061    #[inline(always)]
1062    pub fn infsel(&self) -> INFSEL_R {
1063        INFSEL_R::new(((self.bits >> 26) & 1) != 0)
1064    }
1065}
1066impl W {
1067    #[doc = "Bits 0:1 - MAC Receive Input 0"]
1068    #[inline(always)]
1069    pub fn rxd0(&mut self) -> RXD0_W<ETH0_CON_SPEC> {
1070        RXD0_W::new(self, 0)
1071    }
1072    #[doc = "Bits 2:3 - MAC Receive Input 1"]
1073    #[inline(always)]
1074    pub fn rxd1(&mut self) -> RXD1_W<ETH0_CON_SPEC> {
1075        RXD1_W::new(self, 2)
1076    }
1077    #[doc = "Bits 4:5 - MAC Receive Input 2"]
1078    #[inline(always)]
1079    pub fn rxd2(&mut self) -> RXD2_W<ETH0_CON_SPEC> {
1080        RXD2_W::new(self, 4)
1081    }
1082    #[doc = "Bits 6:7 - MAC Receive Input 3"]
1083    #[inline(always)]
1084    pub fn rxd3(&mut self) -> RXD3_W<ETH0_CON_SPEC> {
1085        RXD3_W::new(self, 6)
1086    }
1087    #[doc = "Bits 8:9 - RMII clock input"]
1088    #[inline(always)]
1089    pub fn clk_rmii(&mut self) -> CLK_RMII_W<ETH0_CON_SPEC> {
1090        CLK_RMII_W::new(self, 8)
1091    }
1092    #[doc = "Bits 10:11 - CRS_DV input"]
1093    #[inline(always)]
1094    pub fn crs_dv(&mut self) -> CRS_DV_W<ETH0_CON_SPEC> {
1095        CRS_DV_W::new(self, 10)
1096    }
1097    #[doc = "Bits 12:13 - CRS input"]
1098    #[inline(always)]
1099    pub fn crs(&mut self) -> CRS_W<ETH0_CON_SPEC> {
1100        CRS_W::new(self, 12)
1101    }
1102    #[doc = "Bits 14:15 - RXER Input"]
1103    #[inline(always)]
1104    pub fn rxer(&mut self) -> RXER_W<ETH0_CON_SPEC> {
1105        RXER_W::new(self, 14)
1106    }
1107    #[doc = "Bits 16:17 - COL input"]
1108    #[inline(always)]
1109    pub fn col(&mut self) -> COL_W<ETH0_CON_SPEC> {
1110        COL_W::new(self, 16)
1111    }
1112    #[doc = "Bits 18:19 - CLK_TX input"]
1113    #[inline(always)]
1114    pub fn clk_tx(&mut self) -> CLK_TX_W<ETH0_CON_SPEC> {
1115        CLK_TX_W::new(self, 18)
1116    }
1117    #[doc = "Bits 22:23 - MDIO Input Select"]
1118    #[inline(always)]
1119    pub fn mdio(&mut self) -> MDIO_W<ETH0_CON_SPEC> {
1120        MDIO_W::new(self, 22)
1121    }
1122    #[doc = "Bit 26 - Ethernet MAC Interface Selection"]
1123    #[inline(always)]
1124    pub fn infsel(&mut self) -> INFSEL_W<ETH0_CON_SPEC> {
1125        INFSEL_W::new(self, 26)
1126    }
1127}
1128#[doc = "Ethernet 0 Port Control Register\n\nYou can [`read`](crate::Reg::read) this register and get [`eth0_con::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`eth0_con::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1129pub struct ETH0_CON_SPEC;
1130impl crate::RegisterSpec for ETH0_CON_SPEC {
1131    type Ux = u32;
1132}
1133#[doc = "`read()` method returns [`eth0_con::R`](R) reader structure"]
1134impl crate::Readable for ETH0_CON_SPEC {}
1135#[doc = "`write(|w| ..)` method takes [`eth0_con::W`](W) writer structure"]
1136impl crate::Writable for ETH0_CON_SPEC {
1137    type Safety = crate::Unsafe;
1138    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1139    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1140}
1141#[doc = "`reset()` method sets ETH0_CON to value 0"]
1142impl crate::Resettable for ETH0_CON_SPEC {
1143    const RESET_VALUE: u32 = 0;
1144}
xmc4500/eth0_con/eth0_con.rs

xmc4500/eth0_con/
eth0_con.rs
