stm32l4x2_pac/sdmmc/
icr.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::ICR {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct CEATAENDCR {
47    bits: bool,
48}
49impl CEATAENDCR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct SDIOITCR {
68    bits: bool,
69}
70impl SDIOITCR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct DBCKENDCR {
89    bits: bool,
90}
91impl DBCKENDCR {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bit(&self) -> bool {
95        self.bits
96    }
97    #[doc = r" Returns `true` if the bit is clear (0)"]
98    #[inline]
99    pub fn bit_is_clear(&self) -> bool {
100        !self.bit()
101    }
102    #[doc = r" Returns `true` if the bit is set (1)"]
103    #[inline]
104    pub fn bit_is_set(&self) -> bool {
105        self.bit()
106    }
107}
108#[doc = r" Value of the field"]
109pub struct STBITERRCR {
110    bits: bool,
111}
112impl STBITERRCR {
113    #[doc = r" Value of the field as raw bits"]
114    #[inline]
115    pub fn bit(&self) -> bool {
116        self.bits
117    }
118    #[doc = r" Returns `true` if the bit is clear (0)"]
119    #[inline]
120    pub fn bit_is_clear(&self) -> bool {
121        !self.bit()
122    }
123    #[doc = r" Returns `true` if the bit is set (1)"]
124    #[inline]
125    pub fn bit_is_set(&self) -> bool {
126        self.bit()
127    }
128}
129#[doc = r" Value of the field"]
130pub struct DATAENDCR {
131    bits: bool,
132}
133impl DATAENDCR {
134    #[doc = r" Value of the field as raw bits"]
135    #[inline]
136    pub fn bit(&self) -> bool {
137        self.bits
138    }
139    #[doc = r" Returns `true` if the bit is clear (0)"]
140    #[inline]
141    pub fn bit_is_clear(&self) -> bool {
142        !self.bit()
143    }
144    #[doc = r" Returns `true` if the bit is set (1)"]
145    #[inline]
146    pub fn bit_is_set(&self) -> bool {
147        self.bit()
148    }
149}
150#[doc = r" Value of the field"]
151pub struct CMDSENTCR {
152    bits: bool,
153}
154impl CMDSENTCR {
155    #[doc = r" Value of the field as raw bits"]
156    #[inline]
157    pub fn bit(&self) -> bool {
158        self.bits
159    }
160    #[doc = r" Returns `true` if the bit is clear (0)"]
161    #[inline]
162    pub fn bit_is_clear(&self) -> bool {
163        !self.bit()
164    }
165    #[doc = r" Returns `true` if the bit is set (1)"]
166    #[inline]
167    pub fn bit_is_set(&self) -> bool {
168        self.bit()
169    }
170}
171#[doc = r" Value of the field"]
172pub struct CMDRENDCR {
173    bits: bool,
174}
175impl CMDRENDCR {
176    #[doc = r" Value of the field as raw bits"]
177    #[inline]
178    pub fn bit(&self) -> bool {
179        self.bits
180    }
181    #[doc = r" Returns `true` if the bit is clear (0)"]
182    #[inline]
183    pub fn bit_is_clear(&self) -> bool {
184        !self.bit()
185    }
186    #[doc = r" Returns `true` if the bit is set (1)"]
187    #[inline]
188    pub fn bit_is_set(&self) -> bool {
189        self.bit()
190    }
191}
192#[doc = r" Value of the field"]
193pub struct RXOVERRCR {
194    bits: bool,
195}
196impl RXOVERRCR {
197    #[doc = r" Value of the field as raw bits"]
198    #[inline]
199    pub fn bit(&self) -> bool {
200        self.bits
201    }
202    #[doc = r" Returns `true` if the bit is clear (0)"]
203    #[inline]
204    pub fn bit_is_clear(&self) -> bool {
205        !self.bit()
206    }
207    #[doc = r" Returns `true` if the bit is set (1)"]
208    #[inline]
209    pub fn bit_is_set(&self) -> bool {
210        self.bit()
211    }
212}
213#[doc = r" Value of the field"]
214pub struct TXUNDERRCR {
215    bits: bool,
216}
217impl TXUNDERRCR {
218    #[doc = r" Value of the field as raw bits"]
219    #[inline]
220    pub fn bit(&self) -> bool {
221        self.bits
222    }
223    #[doc = r" Returns `true` if the bit is clear (0)"]
224    #[inline]
225    pub fn bit_is_clear(&self) -> bool {
226        !self.bit()
227    }
228    #[doc = r" Returns `true` if the bit is set (1)"]
229    #[inline]
230    pub fn bit_is_set(&self) -> bool {
231        self.bit()
232    }
233}
234#[doc = r" Value of the field"]
235pub struct DTIMEOUTCR {
236    bits: bool,
237}
238impl DTIMEOUTCR {
239    #[doc = r" Value of the field as raw bits"]
240    #[inline]
241    pub fn bit(&self) -> bool {
242        self.bits
243    }
244    #[doc = r" Returns `true` if the bit is clear (0)"]
245    #[inline]
246    pub fn bit_is_clear(&self) -> bool {
247        !self.bit()
248    }
249    #[doc = r" Returns `true` if the bit is set (1)"]
250    #[inline]
251    pub fn bit_is_set(&self) -> bool {
252        self.bit()
253    }
254}
255#[doc = r" Value of the field"]
256pub struct CTIMEOUTCR {
257    bits: bool,
258}
259impl CTIMEOUTCR {
260    #[doc = r" Value of the field as raw bits"]
261    #[inline]
262    pub fn bit(&self) -> bool {
263        self.bits
264    }
265    #[doc = r" Returns `true` if the bit is clear (0)"]
266    #[inline]
267    pub fn bit_is_clear(&self) -> bool {
268        !self.bit()
269    }
270    #[doc = r" Returns `true` if the bit is set (1)"]
271    #[inline]
272    pub fn bit_is_set(&self) -> bool {
273        self.bit()
274    }
275}
276#[doc = r" Value of the field"]
277pub struct DCRCFAILCR {
278    bits: bool,
279}
280impl DCRCFAILCR {
281    #[doc = r" Value of the field as raw bits"]
282    #[inline]
283    pub fn bit(&self) -> bool {
284        self.bits
285    }
286    #[doc = r" Returns `true` if the bit is clear (0)"]
287    #[inline]
288    pub fn bit_is_clear(&self) -> bool {
289        !self.bit()
290    }
291    #[doc = r" Returns `true` if the bit is set (1)"]
292    #[inline]
293    pub fn bit_is_set(&self) -> bool {
294        self.bit()
295    }
296}
297#[doc = r" Value of the field"]
298pub struct CCRCFAILCR {
299    bits: bool,
300}
301impl CCRCFAILCR {
302    #[doc = r" Value of the field as raw bits"]
303    #[inline]
304    pub fn bit(&self) -> bool {
305        self.bits
306    }
307    #[doc = r" Returns `true` if the bit is clear (0)"]
308    #[inline]
309    pub fn bit_is_clear(&self) -> bool {
310        !self.bit()
311    }
312    #[doc = r" Returns `true` if the bit is set (1)"]
313    #[inline]
314    pub fn bit_is_set(&self) -> bool {
315        self.bit()
316    }
317}
318#[doc = r" Proxy"]
319pub struct _CEATAENDCW<'a> {
320    w: &'a mut W,
321}
322impl<'a> _CEATAENDCW<'a> {
323    #[doc = r" Sets the field bit"]
324    pub fn set_bit(self) -> &'a mut W {
325        self.bit(true)
326    }
327    #[doc = r" Clears the field bit"]
328    pub fn clear_bit(self) -> &'a mut W {
329        self.bit(false)
330    }
331    #[doc = r" Writes raw bits to the field"]
332    #[inline]
333    pub fn bit(self, value: bool) -> &'a mut W {
334        const MASK: bool = true;
335        const OFFSET: u8 = 23;
336        self.w.bits &= !((MASK as u32) << OFFSET);
337        self.w.bits |= ((value & MASK) as u32) << OFFSET;
338        self.w
339    }
340}
341#[doc = r" Proxy"]
342pub struct _SDIOITCW<'a> {
343    w: &'a mut W,
344}
345impl<'a> _SDIOITCW<'a> {
346    #[doc = r" Sets the field bit"]
347    pub fn set_bit(self) -> &'a mut W {
348        self.bit(true)
349    }
350    #[doc = r" Clears the field bit"]
351    pub fn clear_bit(self) -> &'a mut W {
352        self.bit(false)
353    }
354    #[doc = r" Writes raw bits to the field"]
355    #[inline]
356    pub fn bit(self, value: bool) -> &'a mut W {
357        const MASK: bool = true;
358        const OFFSET: u8 = 22;
359        self.w.bits &= !((MASK as u32) << OFFSET);
360        self.w.bits |= ((value & MASK) as u32) << OFFSET;
361        self.w
362    }
363}
364#[doc = r" Proxy"]
365pub struct _DBCKENDCW<'a> {
366    w: &'a mut W,
367}
368impl<'a> _DBCKENDCW<'a> {
369    #[doc = r" Sets the field bit"]
370    pub fn set_bit(self) -> &'a mut W {
371        self.bit(true)
372    }
373    #[doc = r" Clears the field bit"]
374    pub fn clear_bit(self) -> &'a mut W {
375        self.bit(false)
376    }
377    #[doc = r" Writes raw bits to the field"]
378    #[inline]
379    pub fn bit(self, value: bool) -> &'a mut W {
380        const MASK: bool = true;
381        const OFFSET: u8 = 10;
382        self.w.bits &= !((MASK as u32) << OFFSET);
383        self.w.bits |= ((value & MASK) as u32) << OFFSET;
384        self.w
385    }
386}
387#[doc = r" Proxy"]
388pub struct _STBITERRCW<'a> {
389    w: &'a mut W,
390}
391impl<'a> _STBITERRCW<'a> {
392    #[doc = r" Sets the field bit"]
393    pub fn set_bit(self) -> &'a mut W {
394        self.bit(true)
395    }
396    #[doc = r" Clears the field bit"]
397    pub fn clear_bit(self) -> &'a mut W {
398        self.bit(false)
399    }
400    #[doc = r" Writes raw bits to the field"]
401    #[inline]
402    pub fn bit(self, value: bool) -> &'a mut W {
403        const MASK: bool = true;
404        const OFFSET: u8 = 9;
405        self.w.bits &= !((MASK as u32) << OFFSET);
406        self.w.bits |= ((value & MASK) as u32) << OFFSET;
407        self.w
408    }
409}
410#[doc = r" Proxy"]
411pub struct _DATAENDCW<'a> {
412    w: &'a mut W,
413}
414impl<'a> _DATAENDCW<'a> {
415    #[doc = r" Sets the field bit"]
416    pub fn set_bit(self) -> &'a mut W {
417        self.bit(true)
418    }
419    #[doc = r" Clears the field bit"]
420    pub fn clear_bit(self) -> &'a mut W {
421        self.bit(false)
422    }
423    #[doc = r" Writes raw bits to the field"]
424    #[inline]
425    pub fn bit(self, value: bool) -> &'a mut W {
426        const MASK: bool = true;
427        const OFFSET: u8 = 8;
428        self.w.bits &= !((MASK as u32) << OFFSET);
429        self.w.bits |= ((value & MASK) as u32) << OFFSET;
430        self.w
431    }
432}
433#[doc = r" Proxy"]
434pub struct _CMDSENTCW<'a> {
435    w: &'a mut W,
436}
437impl<'a> _CMDSENTCW<'a> {
438    #[doc = r" Sets the field bit"]
439    pub fn set_bit(self) -> &'a mut W {
440        self.bit(true)
441    }
442    #[doc = r" Clears the field bit"]
443    pub fn clear_bit(self) -> &'a mut W {
444        self.bit(false)
445    }
446    #[doc = r" Writes raw bits to the field"]
447    #[inline]
448    pub fn bit(self, value: bool) -> &'a mut W {
449        const MASK: bool = true;
450        const OFFSET: u8 = 7;
451        self.w.bits &= !((MASK as u32) << OFFSET);
452        self.w.bits |= ((value & MASK) as u32) << OFFSET;
453        self.w
454    }
455}
456#[doc = r" Proxy"]
457pub struct _CMDRENDCW<'a> {
458    w: &'a mut W,
459}
460impl<'a> _CMDRENDCW<'a> {
461    #[doc = r" Sets the field bit"]
462    pub fn set_bit(self) -> &'a mut W {
463        self.bit(true)
464    }
465    #[doc = r" Clears the field bit"]
466    pub fn clear_bit(self) -> &'a mut W {
467        self.bit(false)
468    }
469    #[doc = r" Writes raw bits to the field"]
470    #[inline]
471    pub fn bit(self, value: bool) -> &'a mut W {
472        const MASK: bool = true;
473        const OFFSET: u8 = 6;
474        self.w.bits &= !((MASK as u32) << OFFSET);
475        self.w.bits |= ((value & MASK) as u32) << OFFSET;
476        self.w
477    }
478}
479#[doc = r" Proxy"]
480pub struct _RXOVERRCW<'a> {
481    w: &'a mut W,
482}
483impl<'a> _RXOVERRCW<'a> {
484    #[doc = r" Sets the field bit"]
485    pub fn set_bit(self) -> &'a mut W {
486        self.bit(true)
487    }
488    #[doc = r" Clears the field bit"]
489    pub fn clear_bit(self) -> &'a mut W {
490        self.bit(false)
491    }
492    #[doc = r" Writes raw bits to the field"]
493    #[inline]
494    pub fn bit(self, value: bool) -> &'a mut W {
495        const MASK: bool = true;
496        const OFFSET: u8 = 5;
497        self.w.bits &= !((MASK as u32) << OFFSET);
498        self.w.bits |= ((value & MASK) as u32) << OFFSET;
499        self.w
500    }
501}
502#[doc = r" Proxy"]
503pub struct _TXUNDERRCW<'a> {
504    w: &'a mut W,
505}
506impl<'a> _TXUNDERRCW<'a> {
507    #[doc = r" Sets the field bit"]
508    pub fn set_bit(self) -> &'a mut W {
509        self.bit(true)
510    }
511    #[doc = r" Clears the field bit"]
512    pub fn clear_bit(self) -> &'a mut W {
513        self.bit(false)
514    }
515    #[doc = r" Writes raw bits to the field"]
516    #[inline]
517    pub fn bit(self, value: bool) -> &'a mut W {
518        const MASK: bool = true;
519        const OFFSET: u8 = 4;
520        self.w.bits &= !((MASK as u32) << OFFSET);
521        self.w.bits |= ((value & MASK) as u32) << OFFSET;
522        self.w
523    }
524}
525#[doc = r" Proxy"]
526pub struct _DTIMEOUTCW<'a> {
527    w: &'a mut W,
528}
529impl<'a> _DTIMEOUTCW<'a> {
530    #[doc = r" Sets the field bit"]
531    pub fn set_bit(self) -> &'a mut W {
532        self.bit(true)
533    }
534    #[doc = r" Clears the field bit"]
535    pub fn clear_bit(self) -> &'a mut W {
536        self.bit(false)
537    }
538    #[doc = r" Writes raw bits to the field"]
539    #[inline]
540    pub fn bit(self, value: bool) -> &'a mut W {
541        const MASK: bool = true;
542        const OFFSET: u8 = 3;
543        self.w.bits &= !((MASK as u32) << OFFSET);
544        self.w.bits |= ((value & MASK) as u32) << OFFSET;
545        self.w
546    }
547}
548#[doc = r" Proxy"]
549pub struct _CTIMEOUTCW<'a> {
550    w: &'a mut W,
551}
552impl<'a> _CTIMEOUTCW<'a> {
553    #[doc = r" Sets the field bit"]
554    pub fn set_bit(self) -> &'a mut W {
555        self.bit(true)
556    }
557    #[doc = r" Clears the field bit"]
558    pub fn clear_bit(self) -> &'a mut W {
559        self.bit(false)
560    }
561    #[doc = r" Writes raw bits to the field"]
562    #[inline]
563    pub fn bit(self, value: bool) -> &'a mut W {
564        const MASK: bool = true;
565        const OFFSET: u8 = 2;
566        self.w.bits &= !((MASK as u32) << OFFSET);
567        self.w.bits |= ((value & MASK) as u32) << OFFSET;
568        self.w
569    }
570}
571#[doc = r" Proxy"]
572pub struct _DCRCFAILCW<'a> {
573    w: &'a mut W,
574}
575impl<'a> _DCRCFAILCW<'a> {
576    #[doc = r" Sets the field bit"]
577    pub fn set_bit(self) -> &'a mut W {
578        self.bit(true)
579    }
580    #[doc = r" Clears the field bit"]
581    pub fn clear_bit(self) -> &'a mut W {
582        self.bit(false)
583    }
584    #[doc = r" Writes raw bits to the field"]
585    #[inline]
586    pub fn bit(self, value: bool) -> &'a mut W {
587        const MASK: bool = true;
588        const OFFSET: u8 = 1;
589        self.w.bits &= !((MASK as u32) << OFFSET);
590        self.w.bits |= ((value & MASK) as u32) << OFFSET;
591        self.w
592    }
593}
594#[doc = r" Proxy"]
595pub struct _CCRCFAILCW<'a> {
596    w: &'a mut W,
597}
598impl<'a> _CCRCFAILCW<'a> {
599    #[doc = r" Sets the field bit"]
600    pub fn set_bit(self) -> &'a mut W {
601        self.bit(true)
602    }
603    #[doc = r" Clears the field bit"]
604    pub fn clear_bit(self) -> &'a mut W {
605        self.bit(false)
606    }
607    #[doc = r" Writes raw bits to the field"]
608    #[inline]
609    pub fn bit(self, value: bool) -> &'a mut W {
610        const MASK: bool = true;
611        const OFFSET: u8 = 0;
612        self.w.bits &= !((MASK as u32) << OFFSET);
613        self.w.bits |= ((value & MASK) as u32) << OFFSET;
614        self.w
615    }
616}
617impl R {
618    #[doc = r" Value of the register as raw bits"]
619    #[inline]
620    pub fn bits(&self) -> u32 {
621        self.bits
622    }
623    #[doc = "Bit 23 - CEATAEND flag clear bit"]
624    #[inline]
625    pub fn ceataendc(&self) -> CEATAENDCR {
626        let bits = {
627            const MASK: bool = true;
628            const OFFSET: u8 = 23;
629            ((self.bits >> OFFSET) & MASK as u32) != 0
630        };
631        CEATAENDCR { bits }
632    }
633    #[doc = "Bit 22 - SDIOIT flag clear bit"]
634    #[inline]
635    pub fn sdioitc(&self) -> SDIOITCR {
636        let bits = {
637            const MASK: bool = true;
638            const OFFSET: u8 = 22;
639            ((self.bits >> OFFSET) & MASK as u32) != 0
640        };
641        SDIOITCR { bits }
642    }
643    #[doc = "Bit 10 - DBCKEND flag clear bit"]
644    #[inline]
645    pub fn dbckendc(&self) -> DBCKENDCR {
646        let bits = {
647            const MASK: bool = true;
648            const OFFSET: u8 = 10;
649            ((self.bits >> OFFSET) & MASK as u32) != 0
650        };
651        DBCKENDCR { bits }
652    }
653    #[doc = "Bit 9 - STBITERR flag clear bit"]
654    #[inline]
655    pub fn stbiterrc(&self) -> STBITERRCR {
656        let bits = {
657            const MASK: bool = true;
658            const OFFSET: u8 = 9;
659            ((self.bits >> OFFSET) & MASK as u32) != 0
660        };
661        STBITERRCR { bits }
662    }
663    #[doc = "Bit 8 - DATAEND flag clear bit"]
664    #[inline]
665    pub fn dataendc(&self) -> DATAENDCR {
666        let bits = {
667            const MASK: bool = true;
668            const OFFSET: u8 = 8;
669            ((self.bits >> OFFSET) & MASK as u32) != 0
670        };
671        DATAENDCR { bits }
672    }
673    #[doc = "Bit 7 - CMDSENT flag clear bit"]
674    #[inline]
675    pub fn cmdsentc(&self) -> CMDSENTCR {
676        let bits = {
677            const MASK: bool = true;
678            const OFFSET: u8 = 7;
679            ((self.bits >> OFFSET) & MASK as u32) != 0
680        };
681        CMDSENTCR { bits }
682    }
683    #[doc = "Bit 6 - CMDREND flag clear bit"]
684    #[inline]
685    pub fn cmdrendc(&self) -> CMDRENDCR {
686        let bits = {
687            const MASK: bool = true;
688            const OFFSET: u8 = 6;
689            ((self.bits >> OFFSET) & MASK as u32) != 0
690        };
691        CMDRENDCR { bits }
692    }
693    #[doc = "Bit 5 - RXOVERR flag clear bit"]
694    #[inline]
695    pub fn rxoverrc(&self) -> RXOVERRCR {
696        let bits = {
697            const MASK: bool = true;
698            const OFFSET: u8 = 5;
699            ((self.bits >> OFFSET) & MASK as u32) != 0
700        };
701        RXOVERRCR { bits }
702    }
703    #[doc = "Bit 4 - TXUNDERR flag clear bit"]
704    #[inline]
705    pub fn txunderrc(&self) -> TXUNDERRCR {
706        let bits = {
707            const MASK: bool = true;
708            const OFFSET: u8 = 4;
709            ((self.bits >> OFFSET) & MASK as u32) != 0
710        };
711        TXUNDERRCR { bits }
712    }
713    #[doc = "Bit 3 - DTIMEOUT flag clear bit"]
714    #[inline]
715    pub fn dtimeoutc(&self) -> DTIMEOUTCR {
716        let bits = {
717            const MASK: bool = true;
718            const OFFSET: u8 = 3;
719            ((self.bits >> OFFSET) & MASK as u32) != 0
720        };
721        DTIMEOUTCR { bits }
722    }
723    #[doc = "Bit 2 - CTIMEOUT flag clear bit"]
724    #[inline]
725    pub fn ctimeoutc(&self) -> CTIMEOUTCR {
726        let bits = {
727            const MASK: bool = true;
728            const OFFSET: u8 = 2;
729            ((self.bits >> OFFSET) & MASK as u32) != 0
730        };
731        CTIMEOUTCR { bits }
732    }
733    #[doc = "Bit 1 - DCRCFAIL flag clear bit"]
734    #[inline]
735    pub fn dcrcfailc(&self) -> DCRCFAILCR {
736        let bits = {
737            const MASK: bool = true;
738            const OFFSET: u8 = 1;
739            ((self.bits >> OFFSET) & MASK as u32) != 0
740        };
741        DCRCFAILCR { bits }
742    }
743    #[doc = "Bit 0 - CCRCFAIL flag clear bit"]
744    #[inline]
745    pub fn ccrcfailc(&self) -> CCRCFAILCR {
746        let bits = {
747            const MASK: bool = true;
748            const OFFSET: u8 = 0;
749            ((self.bits >> OFFSET) & MASK as u32) != 0
750        };
751        CCRCFAILCR { bits }
752    }
753}
754impl W {
755    #[doc = r" Reset value of the register"]
756    #[inline]
757    pub fn reset_value() -> W {
758        W { bits: 0 }
759    }
760    #[doc = r" Writes raw bits to the register"]
761    #[inline]
762    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
763        self.bits = bits;
764        self
765    }
766    #[doc = "Bit 23 - CEATAEND flag clear bit"]
767    #[inline]
768    pub fn ceataendc(&mut self) -> _CEATAENDCW {
769        _CEATAENDCW { w: self }
770    }
771    #[doc = "Bit 22 - SDIOIT flag clear bit"]
772    #[inline]
773    pub fn sdioitc(&mut self) -> _SDIOITCW {
774        _SDIOITCW { w: self }
775    }
776    #[doc = "Bit 10 - DBCKEND flag clear bit"]
777    #[inline]
778    pub fn dbckendc(&mut self) -> _DBCKENDCW {
779        _DBCKENDCW { w: self }
780    }
781    #[doc = "Bit 9 - STBITERR flag clear bit"]
782    #[inline]
783    pub fn stbiterrc(&mut self) -> _STBITERRCW {
784        _STBITERRCW { w: self }
785    }
786    #[doc = "Bit 8 - DATAEND flag clear bit"]
787    #[inline]
788    pub fn dataendc(&mut self) -> _DATAENDCW {
789        _DATAENDCW { w: self }
790    }
791    #[doc = "Bit 7 - CMDSENT flag clear bit"]
792    #[inline]
793    pub fn cmdsentc(&mut self) -> _CMDSENTCW {
794        _CMDSENTCW { w: self }
795    }
796    #[doc = "Bit 6 - CMDREND flag clear bit"]
797    #[inline]
798    pub fn cmdrendc(&mut self) -> _CMDRENDCW {
799        _CMDRENDCW { w: self }
800    }
801    #[doc = "Bit 5 - RXOVERR flag clear bit"]
802    #[inline]
803    pub fn rxoverrc(&mut self) -> _RXOVERRCW {
804        _RXOVERRCW { w: self }
805    }
806    #[doc = "Bit 4 - TXUNDERR flag clear bit"]
807    #[inline]
808    pub fn txunderrc(&mut self) -> _TXUNDERRCW {
809        _TXUNDERRCW { w: self }
810    }
811    #[doc = "Bit 3 - DTIMEOUT flag clear bit"]
812    #[inline]
813    pub fn dtimeoutc(&mut self) -> _DTIMEOUTCW {
814        _DTIMEOUTCW { w: self }
815    }
816    #[doc = "Bit 2 - CTIMEOUT flag clear bit"]
817    #[inline]
818    pub fn ctimeoutc(&mut self) -> _CTIMEOUTCW {
819        _CTIMEOUTCW { w: self }
820    }
821    #[doc = "Bit 1 - DCRCFAIL flag clear bit"]
822    #[inline]
823    pub fn dcrcfailc(&mut self) -> _DCRCFAILCW {
824        _DCRCFAILCW { w: self }
825    }
826    #[doc = "Bit 0 - CCRCFAIL flag clear bit"]
827    #[inline]
828    pub fn ccrcfailc(&mut self) -> _CCRCFAILCW {
829        _CCRCFAILCW { w: self }
830    }
831}
stm32l4x2_pac/sdmmc/icr.rs

stm32l4x2_pac/sdmmc/
icr.rs
