xmc4700/sdmmc/
capabilities.rs

1#[doc = "Register `CAPABILITIES` reader"]
2pub type R = crate::R<CAPABILITIES_SPEC>;
3#[doc = "Timeout Clock Frequency\n\nValue on reset: 48"]
4#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5#[repr(u8)]
6pub enum TIMEOUT_CLOCK_FREQ_A {
7    #[doc = "48: 48 MHz"]
8    VALUE1 = 48,
9}
10impl From<TIMEOUT_CLOCK_FREQ_A> for u8 {
11    #[inline(always)]
12    fn from(variant: TIMEOUT_CLOCK_FREQ_A) -> Self {
13        variant as _
14    }
15}
16impl crate::FieldSpec for TIMEOUT_CLOCK_FREQ_A {
17    type Ux = u8;
18}
19impl crate::IsEnum for TIMEOUT_CLOCK_FREQ_A {}
20#[doc = "Field `TIMEOUT_CLOCK_FREQ` reader - Timeout Clock Frequency"]
21pub type TIMEOUT_CLOCK_FREQ_R = crate::FieldReader<TIMEOUT_CLOCK_FREQ_A>;
22impl TIMEOUT_CLOCK_FREQ_R {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Option<TIMEOUT_CLOCK_FREQ_A> {
26        match self.bits {
27            48 => Some(TIMEOUT_CLOCK_FREQ_A::VALUE1),
28            _ => None,
29        }
30    }
31    #[doc = "48 MHz"]
32    #[inline(always)]
33    pub fn is_value1(&self) -> bool {
34        *self == TIMEOUT_CLOCK_FREQ_A::VALUE1
35    }
36}
37#[doc = "Timeout Clock Unit\n\nValue on reset: 1"]
38#[derive(Clone, Copy, Debug, PartialEq, Eq)]
39pub enum TIMEOUT_CLOCK_UNIT_A {
40    #[doc = "1: MHz"]
41    VALUE1 = 1,
42}
43impl From<TIMEOUT_CLOCK_UNIT_A> for bool {
44    #[inline(always)]
45    fn from(variant: TIMEOUT_CLOCK_UNIT_A) -> Self {
46        variant as u8 != 0
47    }
48}
49#[doc = "Field `TIMEOUT_CLOCK_UNIT` reader - Timeout Clock Unit"]
50pub type TIMEOUT_CLOCK_UNIT_R = crate::BitReader<TIMEOUT_CLOCK_UNIT_A>;
51impl TIMEOUT_CLOCK_UNIT_R {
52    #[doc = "Get enumerated values variant"]
53    #[inline(always)]
54    pub const fn variant(&self) -> Option<TIMEOUT_CLOCK_UNIT_A> {
55        match self.bits {
56            true => Some(TIMEOUT_CLOCK_UNIT_A::VALUE1),
57            _ => None,
58        }
59    }
60    #[doc = "MHz"]
61    #[inline(always)]
62    pub fn is_value1(&self) -> bool {
63        *self == TIMEOUT_CLOCK_UNIT_A::VALUE1
64    }
65}
66#[doc = "Base Clock Frequency for SD Clock\n\nValue on reset: 48"]
67#[derive(Clone, Copy, Debug, PartialEq, Eq)]
68#[repr(u8)]
69pub enum BASE_SD_CLOCK_FREQ_A {
70    #[doc = "48: 48 MHz"]
71    VALUE1 = 48,
72}
73impl From<BASE_SD_CLOCK_FREQ_A> for u8 {
74    #[inline(always)]
75    fn from(variant: BASE_SD_CLOCK_FREQ_A) -> Self {
76        variant as _
77    }
78}
79impl crate::FieldSpec for BASE_SD_CLOCK_FREQ_A {
80    type Ux = u8;
81}
82impl crate::IsEnum for BASE_SD_CLOCK_FREQ_A {}
83#[doc = "Field `BASE_SD_CLOCK_FREQ` reader - Base Clock Frequency for SD Clock"]
84pub type BASE_SD_CLOCK_FREQ_R = crate::FieldReader<BASE_SD_CLOCK_FREQ_A>;
85impl BASE_SD_CLOCK_FREQ_R {
86    #[doc = "Get enumerated values variant"]
87    #[inline(always)]
88    pub const fn variant(&self) -> Option<BASE_SD_CLOCK_FREQ_A> {
89        match self.bits {
90            48 => Some(BASE_SD_CLOCK_FREQ_A::VALUE1),
91            _ => None,
92        }
93    }
94    #[doc = "48 MHz"]
95    #[inline(always)]
96    pub fn is_value1(&self) -> bool {
97        *self == BASE_SD_CLOCK_FREQ_A::VALUE1
98    }
99}
100#[doc = "Max Block Length\n\nValue on reset: 0"]
101#[derive(Clone, Copy, Debug, PartialEq, Eq)]
102#[repr(u8)]
103pub enum MAX_BLOCK_LENGTH_A {
104    #[doc = "0: 512 byte"]
105    VALUE1 = 0,
106}
107impl From<MAX_BLOCK_LENGTH_A> for u8 {
108    #[inline(always)]
109    fn from(variant: MAX_BLOCK_LENGTH_A) -> Self {
110        variant as _
111    }
112}
113impl crate::FieldSpec for MAX_BLOCK_LENGTH_A {
114    type Ux = u8;
115}
116impl crate::IsEnum for MAX_BLOCK_LENGTH_A {}
117#[doc = "Field `MAX_BLOCK_LENGTH` reader - Max Block Length"]
118pub type MAX_BLOCK_LENGTH_R = crate::FieldReader<MAX_BLOCK_LENGTH_A>;
119impl MAX_BLOCK_LENGTH_R {
120    #[doc = "Get enumerated values variant"]
121    #[inline(always)]
122    pub const fn variant(&self) -> Option<MAX_BLOCK_LENGTH_A> {
123        match self.bits {
124            0 => Some(MAX_BLOCK_LENGTH_A::VALUE1),
125            _ => None,
126        }
127    }
128    #[doc = "512 byte"]
129    #[inline(always)]
130    pub fn is_value1(&self) -> bool {
131        *self == MAX_BLOCK_LENGTH_A::VALUE1
132    }
133}
134#[doc = "Extended Media Bus Support\n\nValue on reset: 0"]
135#[derive(Clone, Copy, Debug, PartialEq, Eq)]
136pub enum EXT_MEDIA_BUS_SUPPORT_A {
137    #[doc = "0: Extended Media Bus not supported"]
138    VALUE1 = 0,
139}
140impl From<EXT_MEDIA_BUS_SUPPORT_A> for bool {
141    #[inline(always)]
142    fn from(variant: EXT_MEDIA_BUS_SUPPORT_A) -> Self {
143        variant as u8 != 0
144    }
145}
146#[doc = "Field `EXT_MEDIA_BUS_SUPPORT` reader - Extended Media Bus Support"]
147pub type EXT_MEDIA_BUS_SUPPORT_R = crate::BitReader<EXT_MEDIA_BUS_SUPPORT_A>;
148impl EXT_MEDIA_BUS_SUPPORT_R {
149    #[doc = "Get enumerated values variant"]
150    #[inline(always)]
151    pub const fn variant(&self) -> Option<EXT_MEDIA_BUS_SUPPORT_A> {
152        match self.bits {
153            false => Some(EXT_MEDIA_BUS_SUPPORT_A::VALUE1),
154            _ => None,
155        }
156    }
157    #[doc = "Extended Media Bus not supported"]
158    #[inline(always)]
159    pub fn is_value1(&self) -> bool {
160        *self == EXT_MEDIA_BUS_SUPPORT_A::VALUE1
161    }
162}
163#[doc = "ADMA2 Support\n\nValue on reset: 0"]
164#[derive(Clone, Copy, Debug, PartialEq, Eq)]
165pub enum ADMA2_SUPPORT_A {
166    #[doc = "0: ADMA not supported"]
167    VALUE1 = 0,
168}
169impl From<ADMA2_SUPPORT_A> for bool {
170    #[inline(always)]
171    fn from(variant: ADMA2_SUPPORT_A) -> Self {
172        variant as u8 != 0
173    }
174}
175#[doc = "Field `ADMA2_SUPPORT` reader - ADMA2 Support"]
176pub type ADMA2_SUPPORT_R = crate::BitReader<ADMA2_SUPPORT_A>;
177impl ADMA2_SUPPORT_R {
178    #[doc = "Get enumerated values variant"]
179    #[inline(always)]
180    pub const fn variant(&self) -> Option<ADMA2_SUPPORT_A> {
181        match self.bits {
182            false => Some(ADMA2_SUPPORT_A::VALUE1),
183            _ => None,
184        }
185    }
186    #[doc = "ADMA not supported"]
187    #[inline(always)]
188    pub fn is_value1(&self) -> bool {
189        *self == ADMA2_SUPPORT_A::VALUE1
190    }
191}
192#[doc = "High Speed Support\n\nValue on reset: 1"]
193#[derive(Clone, Copy, Debug, PartialEq, Eq)]
194pub enum HIGH_SPEED_SUPPORT_A {
195    #[doc = "1: High Speed supported"]
196    VALUE1 = 1,
197}
198impl From<HIGH_SPEED_SUPPORT_A> for bool {
199    #[inline(always)]
200    fn from(variant: HIGH_SPEED_SUPPORT_A) -> Self {
201        variant as u8 != 0
202    }
203}
204#[doc = "Field `HIGH_SPEED_SUPPORT` reader - High Speed Support"]
205pub type HIGH_SPEED_SUPPORT_R = crate::BitReader<HIGH_SPEED_SUPPORT_A>;
206impl HIGH_SPEED_SUPPORT_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub const fn variant(&self) -> Option<HIGH_SPEED_SUPPORT_A> {
210        match self.bits {
211            true => Some(HIGH_SPEED_SUPPORT_A::VALUE1),
212            _ => None,
213        }
214    }
215    #[doc = "High Speed supported"]
216    #[inline(always)]
217    pub fn is_value1(&self) -> bool {
218        *self == HIGH_SPEED_SUPPORT_A::VALUE1
219    }
220}
221#[doc = "SDMA Support\n\nValue on reset: 0"]
222#[derive(Clone, Copy, Debug, PartialEq, Eq)]
223pub enum SDMA_SUPPORT_A {
224    #[doc = "0: SDMA not supported"]
225    VALUE1 = 0,
226}
227impl From<SDMA_SUPPORT_A> for bool {
228    #[inline(always)]
229    fn from(variant: SDMA_SUPPORT_A) -> Self {
230        variant as u8 != 0
231    }
232}
233#[doc = "Field `SDMA_SUPPORT` reader - SDMA Support"]
234pub type SDMA_SUPPORT_R = crate::BitReader<SDMA_SUPPORT_A>;
235impl SDMA_SUPPORT_R {
236    #[doc = "Get enumerated values variant"]
237    #[inline(always)]
238    pub const fn variant(&self) -> Option<SDMA_SUPPORT_A> {
239        match self.bits {
240            false => Some(SDMA_SUPPORT_A::VALUE1),
241            _ => None,
242        }
243    }
244    #[doc = "SDMA not supported"]
245    #[inline(always)]
246    pub fn is_value1(&self) -> bool {
247        *self == SDMA_SUPPORT_A::VALUE1
248    }
249}
250#[doc = "Suspend / Resume Support\n\nValue on reset: 1"]
251#[derive(Clone, Copy, Debug, PartialEq, Eq)]
252pub enum SUSPEND_RESUME_SUPPORT_A {
253    #[doc = "1: Supported"]
254    VALUE1 = 1,
255}
256impl From<SUSPEND_RESUME_SUPPORT_A> for bool {
257    #[inline(always)]
258    fn from(variant: SUSPEND_RESUME_SUPPORT_A) -> Self {
259        variant as u8 != 0
260    }
261}
262#[doc = "Field `SUSPEND_RESUME_SUPPORT` reader - Suspend / Resume Support"]
263pub type SUSPEND_RESUME_SUPPORT_R = crate::BitReader<SUSPEND_RESUME_SUPPORT_A>;
264impl SUSPEND_RESUME_SUPPORT_R {
265    #[doc = "Get enumerated values variant"]
266    #[inline(always)]
267    pub const fn variant(&self) -> Option<SUSPEND_RESUME_SUPPORT_A> {
268        match self.bits {
269            true => Some(SUSPEND_RESUME_SUPPORT_A::VALUE1),
270            _ => None,
271        }
272    }
273    #[doc = "Supported"]
274    #[inline(always)]
275    pub fn is_value1(&self) -> bool {
276        *self == SUSPEND_RESUME_SUPPORT_A::VALUE1
277    }
278}
279#[doc = "Voltage Support 3.3V\n\nValue on reset: 1"]
280#[derive(Clone, Copy, Debug, PartialEq, Eq)]
281pub enum VOLTAGE_SUPPORT_3_3V_A {
282    #[doc = "1: 3.3V supported"]
283    VALUE1 = 1,
284}
285impl From<VOLTAGE_SUPPORT_3_3V_A> for bool {
286    #[inline(always)]
287    fn from(variant: VOLTAGE_SUPPORT_3_3V_A) -> Self {
288        variant as u8 != 0
289    }
290}
291#[doc = "Field `VOLTAGE_SUPPORT_3_3V` reader - Voltage Support 3.3V"]
292pub type VOLTAGE_SUPPORT_3_3V_R = crate::BitReader<VOLTAGE_SUPPORT_3_3V_A>;
293impl VOLTAGE_SUPPORT_3_3V_R {
294    #[doc = "Get enumerated values variant"]
295    #[inline(always)]
296    pub const fn variant(&self) -> Option<VOLTAGE_SUPPORT_3_3V_A> {
297        match self.bits {
298            true => Some(VOLTAGE_SUPPORT_3_3V_A::VALUE1),
299            _ => None,
300        }
301    }
302    #[doc = "3.3V supported"]
303    #[inline(always)]
304    pub fn is_value1(&self) -> bool {
305        *self == VOLTAGE_SUPPORT_3_3V_A::VALUE1
306    }
307}
308#[doc = "Voltage Support 3.0V\n\nValue on reset: 0"]
309#[derive(Clone, Copy, Debug, PartialEq, Eq)]
310pub enum VOLTAGE_SUPPORT_3V_A {
311    #[doc = "0: 3.0V not supported"]
312    VALUE1 = 0,
313}
314impl From<VOLTAGE_SUPPORT_3V_A> for bool {
315    #[inline(always)]
316    fn from(variant: VOLTAGE_SUPPORT_3V_A) -> Self {
317        variant as u8 != 0
318    }
319}
320#[doc = "Field `VOLTAGE_SUPPORT_3V` reader - Voltage Support 3.0V"]
321pub type VOLTAGE_SUPPORT_3V_R = crate::BitReader<VOLTAGE_SUPPORT_3V_A>;
322impl VOLTAGE_SUPPORT_3V_R {
323    #[doc = "Get enumerated values variant"]
324    #[inline(always)]
325    pub const fn variant(&self) -> Option<VOLTAGE_SUPPORT_3V_A> {
326        match self.bits {
327            false => Some(VOLTAGE_SUPPORT_3V_A::VALUE1),
328            _ => None,
329        }
330    }
331    #[doc = "3.0V not supported"]
332    #[inline(always)]
333    pub fn is_value1(&self) -> bool {
334        *self == VOLTAGE_SUPPORT_3V_A::VALUE1
335    }
336}
337#[doc = "Voltage Support 1.8V\n\nValue on reset: 0"]
338#[derive(Clone, Copy, Debug, PartialEq, Eq)]
339pub enum VOLTAGE_SUPPORT_1_8V_A {
340    #[doc = "0: 1.8V not supported"]
341    VALUE1 = 0,
342}
343impl From<VOLTAGE_SUPPORT_1_8V_A> for bool {
344    #[inline(always)]
345    fn from(variant: VOLTAGE_SUPPORT_1_8V_A) -> Self {
346        variant as u8 != 0
347    }
348}
349#[doc = "Field `VOLTAGE_SUPPORT_1_8V` reader - Voltage Support 1.8V"]
350pub type VOLTAGE_SUPPORT_1_8V_R = crate::BitReader<VOLTAGE_SUPPORT_1_8V_A>;
351impl VOLTAGE_SUPPORT_1_8V_R {
352    #[doc = "Get enumerated values variant"]
353    #[inline(always)]
354    pub const fn variant(&self) -> Option<VOLTAGE_SUPPORT_1_8V_A> {
355        match self.bits {
356            false => Some(VOLTAGE_SUPPORT_1_8V_A::VALUE1),
357            _ => None,
358        }
359    }
360    #[doc = "1.8V not supported"]
361    #[inline(always)]
362    pub fn is_value1(&self) -> bool {
363        *self == VOLTAGE_SUPPORT_1_8V_A::VALUE1
364    }
365}
366#[doc = "64-bit System Bus Support\n\nValue on reset: 0"]
367#[derive(Clone, Copy, Debug, PartialEq, Eq)]
368pub enum SYSBUS_64_SUPPORT_A {
369    #[doc = "0: Does not support 64-bit system address"]
370    VALUE1 = 0,
371}
372impl From<SYSBUS_64_SUPPORT_A> for bool {
373    #[inline(always)]
374    fn from(variant: SYSBUS_64_SUPPORT_A) -> Self {
375        variant as u8 != 0
376    }
377}
378#[doc = "Field `SYSBUS_64_SUPPORT` reader - 64-bit System Bus Support"]
379pub type SYSBUS_64_SUPPORT_R = crate::BitReader<SYSBUS_64_SUPPORT_A>;
380impl SYSBUS_64_SUPPORT_R {
381    #[doc = "Get enumerated values variant"]
382    #[inline(always)]
383    pub const fn variant(&self) -> Option<SYSBUS_64_SUPPORT_A> {
384        match self.bits {
385            false => Some(SYSBUS_64_SUPPORT_A::VALUE1),
386            _ => None,
387        }
388    }
389    #[doc = "Does not support 64-bit system address"]
390    #[inline(always)]
391    pub fn is_value1(&self) -> bool {
392        *self == SYSBUS_64_SUPPORT_A::VALUE1
393    }
394}
395#[doc = "Asynchronous Interrupt Support\n\nValue on reset: 0"]
396#[derive(Clone, Copy, Debug, PartialEq, Eq)]
397pub enum ASYNC_INT_SUPPORT_A {
398    #[doc = "0: Asynchronous Interrupt not supported"]
399    VALUE1 = 0,
400}
401impl From<ASYNC_INT_SUPPORT_A> for bool {
402    #[inline(always)]
403    fn from(variant: ASYNC_INT_SUPPORT_A) -> Self {
404        variant as u8 != 0
405    }
406}
407#[doc = "Field `ASYNC_INT_SUPPORT` reader - Asynchronous Interrupt Support"]
408pub type ASYNC_INT_SUPPORT_R = crate::BitReader<ASYNC_INT_SUPPORT_A>;
409impl ASYNC_INT_SUPPORT_R {
410    #[doc = "Get enumerated values variant"]
411    #[inline(always)]
412    pub const fn variant(&self) -> Option<ASYNC_INT_SUPPORT_A> {
413        match self.bits {
414            false => Some(ASYNC_INT_SUPPORT_A::VALUE1),
415            _ => None,
416        }
417    }
418    #[doc = "Asynchronous Interrupt not supported"]
419    #[inline(always)]
420    pub fn is_value1(&self) -> bool {
421        *self == ASYNC_INT_SUPPORT_A::VALUE1
422    }
423}
424#[doc = "Slot Type\n\nValue on reset: 0"]
425#[derive(Clone, Copy, Debug, PartialEq, Eq)]
426#[repr(u8)]
427pub enum SLOT_TYPE_A {
428    #[doc = "0: Removable Card Slot"]
429    VALUE1 = 0,
430}
431impl From<SLOT_TYPE_A> for u8 {
432    #[inline(always)]
433    fn from(variant: SLOT_TYPE_A) -> Self {
434        variant as _
435    }
436}
437impl crate::FieldSpec for SLOT_TYPE_A {
438    type Ux = u8;
439}
440impl crate::IsEnum for SLOT_TYPE_A {}
441#[doc = "Field `SLOT_TYPE` reader - Slot Type"]
442pub type SLOT_TYPE_R = crate::FieldReader<SLOT_TYPE_A>;
443impl SLOT_TYPE_R {
444    #[doc = "Get enumerated values variant"]
445    #[inline(always)]
446    pub const fn variant(&self) -> Option<SLOT_TYPE_A> {
447        match self.bits {
448            0 => Some(SLOT_TYPE_A::VALUE1),
449            _ => None,
450        }
451    }
452    #[doc = "Removable Card Slot"]
453    #[inline(always)]
454    pub fn is_value1(&self) -> bool {
455        *self == SLOT_TYPE_A::VALUE1
456    }
457}
458impl R {
459    #[doc = "Bits 0:5 - Timeout Clock Frequency"]
460    #[inline(always)]
461    pub fn timeout_clock_freq(&self) -> TIMEOUT_CLOCK_FREQ_R {
462        TIMEOUT_CLOCK_FREQ_R::new((self.bits & 0x3f) as u8)
463    }
464    #[doc = "Bit 7 - Timeout Clock Unit"]
465    #[inline(always)]
466    pub fn timeout_clock_unit(&self) -> TIMEOUT_CLOCK_UNIT_R {
467        TIMEOUT_CLOCK_UNIT_R::new(((self.bits >> 7) & 1) != 0)
468    }
469    #[doc = "Bits 8:15 - Base Clock Frequency for SD Clock"]
470    #[inline(always)]
471    pub fn base_sd_clock_freq(&self) -> BASE_SD_CLOCK_FREQ_R {
472        BASE_SD_CLOCK_FREQ_R::new(((self.bits >> 8) & 0xff) as u8)
473    }
474    #[doc = "Bits 16:17 - Max Block Length"]
475    #[inline(always)]
476    pub fn max_block_length(&self) -> MAX_BLOCK_LENGTH_R {
477        MAX_BLOCK_LENGTH_R::new(((self.bits >> 16) & 3) as u8)
478    }
479    #[doc = "Bit 18 - Extended Media Bus Support"]
480    #[inline(always)]
481    pub fn ext_media_bus_support(&self) -> EXT_MEDIA_BUS_SUPPORT_R {
482        EXT_MEDIA_BUS_SUPPORT_R::new(((self.bits >> 18) & 1) != 0)
483    }
484    #[doc = "Bit 19 - ADMA2 Support"]
485    #[inline(always)]
486    pub fn adma2_support(&self) -> ADMA2_SUPPORT_R {
487        ADMA2_SUPPORT_R::new(((self.bits >> 19) & 1) != 0)
488    }
489    #[doc = "Bit 21 - High Speed Support"]
490    #[inline(always)]
491    pub fn high_speed_support(&self) -> HIGH_SPEED_SUPPORT_R {
492        HIGH_SPEED_SUPPORT_R::new(((self.bits >> 21) & 1) != 0)
493    }
494    #[doc = "Bit 22 - SDMA Support"]
495    #[inline(always)]
496    pub fn sdma_support(&self) -> SDMA_SUPPORT_R {
497        SDMA_SUPPORT_R::new(((self.bits >> 22) & 1) != 0)
498    }
499    #[doc = "Bit 23 - Suspend / Resume Support"]
500    #[inline(always)]
501    pub fn suspend_resume_support(&self) -> SUSPEND_RESUME_SUPPORT_R {
502        SUSPEND_RESUME_SUPPORT_R::new(((self.bits >> 23) & 1) != 0)
503    }
504    #[doc = "Bit 24 - Voltage Support 3.3V"]
505    #[inline(always)]
506    pub fn voltage_support_3_3v(&self) -> VOLTAGE_SUPPORT_3_3V_R {
507        VOLTAGE_SUPPORT_3_3V_R::new(((self.bits >> 24) & 1) != 0)
508    }
509    #[doc = "Bit 25 - Voltage Support 3.0V"]
510    #[inline(always)]
511    pub fn voltage_support_3v(&self) -> VOLTAGE_SUPPORT_3V_R {
512        VOLTAGE_SUPPORT_3V_R::new(((self.bits >> 25) & 1) != 0)
513    }
514    #[doc = "Bit 26 - Voltage Support 1.8V"]
515    #[inline(always)]
516    pub fn voltage_support_1_8v(&self) -> VOLTAGE_SUPPORT_1_8V_R {
517        VOLTAGE_SUPPORT_1_8V_R::new(((self.bits >> 26) & 1) != 0)
518    }
519    #[doc = "Bit 28 - 64-bit System Bus Support"]
520    #[inline(always)]
521    pub fn sysbus_64_support(&self) -> SYSBUS_64_SUPPORT_R {
522        SYSBUS_64_SUPPORT_R::new(((self.bits >> 28) & 1) != 0)
523    }
524    #[doc = "Bit 29 - Asynchronous Interrupt Support"]
525    #[inline(always)]
526    pub fn async_int_support(&self) -> ASYNC_INT_SUPPORT_R {
527        ASYNC_INT_SUPPORT_R::new(((self.bits >> 29) & 1) != 0)
528    }
529    #[doc = "Bits 30:31 - Slot Type"]
530    #[inline(always)]
531    pub fn slot_type(&self) -> SLOT_TYPE_R {
532        SLOT_TYPE_R::new(((self.bits >> 30) & 3) as u8)
533    }
534}
535#[doc = "Capabilities Register\n\nYou can [`read`](crate::Reg::read) this register and get [`capabilities::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
536pub struct CAPABILITIES_SPEC;
537impl crate::RegisterSpec for CAPABILITIES_SPEC {
538    type Ux = u32;
539}
540#[doc = "`read()` method returns [`capabilities::R`](R) reader structure"]
541impl crate::Readable for CAPABILITIES_SPEC {}
542#[doc = "`reset()` method sets CAPABILITIES to value 0x01a0_30b0"]
543impl crate::Resettable for CAPABILITIES_SPEC {
544    const RESET_VALUE: u32 = 0x01a0_30b0;
545}
xmc4700/sdmmc/capabilities.rs

xmc4700/sdmmc/
capabilities.rs
