stm32l4x2_pac/sdmmc/
mask.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::MASK {
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 CEATAENDIER {
47    bits: bool,
48}
49impl CEATAENDIER {
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 SDIOITIER {
68    bits: bool,
69}
70impl SDIOITIER {
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 RXDAVLIER {
89    bits: bool,
90}
91impl RXDAVLIER {
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 TXDAVLIER {
110    bits: bool,
111}
112impl TXDAVLIER {
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 RXFIFOEIER {
131    bits: bool,
132}
133impl RXFIFOEIER {
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 TXFIFOEIER {
152    bits: bool,
153}
154impl TXFIFOEIER {
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 RXFIFOFIER {
173    bits: bool,
174}
175impl RXFIFOFIER {
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 TXFIFOFIER {
194    bits: bool,
195}
196impl TXFIFOFIER {
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 RXFIFOHFIER {
215    bits: bool,
216}
217impl RXFIFOHFIER {
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 TXFIFOHEIER {
236    bits: bool,
237}
238impl TXFIFOHEIER {
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 RXACTIER {
257    bits: bool,
258}
259impl RXACTIER {
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 TXACTIER {
278    bits: bool,
279}
280impl TXACTIER {
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 CMDACTIER {
299    bits: bool,
300}
301impl CMDACTIER {
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" Value of the field"]
319pub struct DBCKENDIER {
320    bits: bool,
321}
322impl DBCKENDIER {
323    #[doc = r" Value of the field as raw bits"]
324    #[inline]
325    pub fn bit(&self) -> bool {
326        self.bits
327    }
328    #[doc = r" Returns `true` if the bit is clear (0)"]
329    #[inline]
330    pub fn bit_is_clear(&self) -> bool {
331        !self.bit()
332    }
333    #[doc = r" Returns `true` if the bit is set (1)"]
334    #[inline]
335    pub fn bit_is_set(&self) -> bool {
336        self.bit()
337    }
338}
339#[doc = r" Value of the field"]
340pub struct STBITERRIER {
341    bits: bool,
342}
343impl STBITERRIER {
344    #[doc = r" Value of the field as raw bits"]
345    #[inline]
346    pub fn bit(&self) -> bool {
347        self.bits
348    }
349    #[doc = r" Returns `true` if the bit is clear (0)"]
350    #[inline]
351    pub fn bit_is_clear(&self) -> bool {
352        !self.bit()
353    }
354    #[doc = r" Returns `true` if the bit is set (1)"]
355    #[inline]
356    pub fn bit_is_set(&self) -> bool {
357        self.bit()
358    }
359}
360#[doc = r" Value of the field"]
361pub struct DATAENDIER {
362    bits: bool,
363}
364impl DATAENDIER {
365    #[doc = r" Value of the field as raw bits"]
366    #[inline]
367    pub fn bit(&self) -> bool {
368        self.bits
369    }
370    #[doc = r" Returns `true` if the bit is clear (0)"]
371    #[inline]
372    pub fn bit_is_clear(&self) -> bool {
373        !self.bit()
374    }
375    #[doc = r" Returns `true` if the bit is set (1)"]
376    #[inline]
377    pub fn bit_is_set(&self) -> bool {
378        self.bit()
379    }
380}
381#[doc = r" Value of the field"]
382pub struct CMDSENTIER {
383    bits: bool,
384}
385impl CMDSENTIER {
386    #[doc = r" Value of the field as raw bits"]
387    #[inline]
388    pub fn bit(&self) -> bool {
389        self.bits
390    }
391    #[doc = r" Returns `true` if the bit is clear (0)"]
392    #[inline]
393    pub fn bit_is_clear(&self) -> bool {
394        !self.bit()
395    }
396    #[doc = r" Returns `true` if the bit is set (1)"]
397    #[inline]
398    pub fn bit_is_set(&self) -> bool {
399        self.bit()
400    }
401}
402#[doc = r" Value of the field"]
403pub struct CMDRENDIER {
404    bits: bool,
405}
406impl CMDRENDIER {
407    #[doc = r" Value of the field as raw bits"]
408    #[inline]
409    pub fn bit(&self) -> bool {
410        self.bits
411    }
412    #[doc = r" Returns `true` if the bit is clear (0)"]
413    #[inline]
414    pub fn bit_is_clear(&self) -> bool {
415        !self.bit()
416    }
417    #[doc = r" Returns `true` if the bit is set (1)"]
418    #[inline]
419    pub fn bit_is_set(&self) -> bool {
420        self.bit()
421    }
422}
423#[doc = r" Value of the field"]
424pub struct RXOVERRIER {
425    bits: bool,
426}
427impl RXOVERRIER {
428    #[doc = r" Value of the field as raw bits"]
429    #[inline]
430    pub fn bit(&self) -> bool {
431        self.bits
432    }
433    #[doc = r" Returns `true` if the bit is clear (0)"]
434    #[inline]
435    pub fn bit_is_clear(&self) -> bool {
436        !self.bit()
437    }
438    #[doc = r" Returns `true` if the bit is set (1)"]
439    #[inline]
440    pub fn bit_is_set(&self) -> bool {
441        self.bit()
442    }
443}
444#[doc = r" Value of the field"]
445pub struct TXUNDERRIER {
446    bits: bool,
447}
448impl TXUNDERRIER {
449    #[doc = r" Value of the field as raw bits"]
450    #[inline]
451    pub fn bit(&self) -> bool {
452        self.bits
453    }
454    #[doc = r" Returns `true` if the bit is clear (0)"]
455    #[inline]
456    pub fn bit_is_clear(&self) -> bool {
457        !self.bit()
458    }
459    #[doc = r" Returns `true` if the bit is set (1)"]
460    #[inline]
461    pub fn bit_is_set(&self) -> bool {
462        self.bit()
463    }
464}
465#[doc = r" Value of the field"]
466pub struct DTIMEOUTIER {
467    bits: bool,
468}
469impl DTIMEOUTIER {
470    #[doc = r" Value of the field as raw bits"]
471    #[inline]
472    pub fn bit(&self) -> bool {
473        self.bits
474    }
475    #[doc = r" Returns `true` if the bit is clear (0)"]
476    #[inline]
477    pub fn bit_is_clear(&self) -> bool {
478        !self.bit()
479    }
480    #[doc = r" Returns `true` if the bit is set (1)"]
481    #[inline]
482    pub fn bit_is_set(&self) -> bool {
483        self.bit()
484    }
485}
486#[doc = r" Value of the field"]
487pub struct CTIMEOUTIER {
488    bits: bool,
489}
490impl CTIMEOUTIER {
491    #[doc = r" Value of the field as raw bits"]
492    #[inline]
493    pub fn bit(&self) -> bool {
494        self.bits
495    }
496    #[doc = r" Returns `true` if the bit is clear (0)"]
497    #[inline]
498    pub fn bit_is_clear(&self) -> bool {
499        !self.bit()
500    }
501    #[doc = r" Returns `true` if the bit is set (1)"]
502    #[inline]
503    pub fn bit_is_set(&self) -> bool {
504        self.bit()
505    }
506}
507#[doc = r" Value of the field"]
508pub struct DCRCFAILIER {
509    bits: bool,
510}
511impl DCRCFAILIER {
512    #[doc = r" Value of the field as raw bits"]
513    #[inline]
514    pub fn bit(&self) -> bool {
515        self.bits
516    }
517    #[doc = r" Returns `true` if the bit is clear (0)"]
518    #[inline]
519    pub fn bit_is_clear(&self) -> bool {
520        !self.bit()
521    }
522    #[doc = r" Returns `true` if the bit is set (1)"]
523    #[inline]
524    pub fn bit_is_set(&self) -> bool {
525        self.bit()
526    }
527}
528#[doc = r" Value of the field"]
529pub struct CCRCFAILIER {
530    bits: bool,
531}
532impl CCRCFAILIER {
533    #[doc = r" Value of the field as raw bits"]
534    #[inline]
535    pub fn bit(&self) -> bool {
536        self.bits
537    }
538    #[doc = r" Returns `true` if the bit is clear (0)"]
539    #[inline]
540    pub fn bit_is_clear(&self) -> bool {
541        !self.bit()
542    }
543    #[doc = r" Returns `true` if the bit is set (1)"]
544    #[inline]
545    pub fn bit_is_set(&self) -> bool {
546        self.bit()
547    }
548}
549#[doc = r" Proxy"]
550pub struct _CEATAENDIEW<'a> {
551    w: &'a mut W,
552}
553impl<'a> _CEATAENDIEW<'a> {
554    #[doc = r" Sets the field bit"]
555    pub fn set_bit(self) -> &'a mut W {
556        self.bit(true)
557    }
558    #[doc = r" Clears the field bit"]
559    pub fn clear_bit(self) -> &'a mut W {
560        self.bit(false)
561    }
562    #[doc = r" Writes raw bits to the field"]
563    #[inline]
564    pub fn bit(self, value: bool) -> &'a mut W {
565        const MASK: bool = true;
566        const OFFSET: u8 = 23;
567        self.w.bits &= !((MASK as u32) << OFFSET);
568        self.w.bits |= ((value & MASK) as u32) << OFFSET;
569        self.w
570    }
571}
572#[doc = r" Proxy"]
573pub struct _SDIOITIEW<'a> {
574    w: &'a mut W,
575}
576impl<'a> _SDIOITIEW<'a> {
577    #[doc = r" Sets the field bit"]
578    pub fn set_bit(self) -> &'a mut W {
579        self.bit(true)
580    }
581    #[doc = r" Clears the field bit"]
582    pub fn clear_bit(self) -> &'a mut W {
583        self.bit(false)
584    }
585    #[doc = r" Writes raw bits to the field"]
586    #[inline]
587    pub fn bit(self, value: bool) -> &'a mut W {
588        const MASK: bool = true;
589        const OFFSET: u8 = 22;
590        self.w.bits &= !((MASK as u32) << OFFSET);
591        self.w.bits |= ((value & MASK) as u32) << OFFSET;
592        self.w
593    }
594}
595#[doc = r" Proxy"]
596pub struct _RXDAVLIEW<'a> {
597    w: &'a mut W,
598}
599impl<'a> _RXDAVLIEW<'a> {
600    #[doc = r" Sets the field bit"]
601    pub fn set_bit(self) -> &'a mut W {
602        self.bit(true)
603    }
604    #[doc = r" Clears the field bit"]
605    pub fn clear_bit(self) -> &'a mut W {
606        self.bit(false)
607    }
608    #[doc = r" Writes raw bits to the field"]
609    #[inline]
610    pub fn bit(self, value: bool) -> &'a mut W {
611        const MASK: bool = true;
612        const OFFSET: u8 = 21;
613        self.w.bits &= !((MASK as u32) << OFFSET);
614        self.w.bits |= ((value & MASK) as u32) << OFFSET;
615        self.w
616    }
617}
618#[doc = r" Proxy"]
619pub struct _TXDAVLIEW<'a> {
620    w: &'a mut W,
621}
622impl<'a> _TXDAVLIEW<'a> {
623    #[doc = r" Sets the field bit"]
624    pub fn set_bit(self) -> &'a mut W {
625        self.bit(true)
626    }
627    #[doc = r" Clears the field bit"]
628    pub fn clear_bit(self) -> &'a mut W {
629        self.bit(false)
630    }
631    #[doc = r" Writes raw bits to the field"]
632    #[inline]
633    pub fn bit(self, value: bool) -> &'a mut W {
634        const MASK: bool = true;
635        const OFFSET: u8 = 20;
636        self.w.bits &= !((MASK as u32) << OFFSET);
637        self.w.bits |= ((value & MASK) as u32) << OFFSET;
638        self.w
639    }
640}
641#[doc = r" Proxy"]
642pub struct _RXFIFOEIEW<'a> {
643    w: &'a mut W,
644}
645impl<'a> _RXFIFOEIEW<'a> {
646    #[doc = r" Sets the field bit"]
647    pub fn set_bit(self) -> &'a mut W {
648        self.bit(true)
649    }
650    #[doc = r" Clears the field bit"]
651    pub fn clear_bit(self) -> &'a mut W {
652        self.bit(false)
653    }
654    #[doc = r" Writes raw bits to the field"]
655    #[inline]
656    pub fn bit(self, value: bool) -> &'a mut W {
657        const MASK: bool = true;
658        const OFFSET: u8 = 19;
659        self.w.bits &= !((MASK as u32) << OFFSET);
660        self.w.bits |= ((value & MASK) as u32) << OFFSET;
661        self.w
662    }
663}
664#[doc = r" Proxy"]
665pub struct _TXFIFOEIEW<'a> {
666    w: &'a mut W,
667}
668impl<'a> _TXFIFOEIEW<'a> {
669    #[doc = r" Sets the field bit"]
670    pub fn set_bit(self) -> &'a mut W {
671        self.bit(true)
672    }
673    #[doc = r" Clears the field bit"]
674    pub fn clear_bit(self) -> &'a mut W {
675        self.bit(false)
676    }
677    #[doc = r" Writes raw bits to the field"]
678    #[inline]
679    pub fn bit(self, value: bool) -> &'a mut W {
680        const MASK: bool = true;
681        const OFFSET: u8 = 18;
682        self.w.bits &= !((MASK as u32) << OFFSET);
683        self.w.bits |= ((value & MASK) as u32) << OFFSET;
684        self.w
685    }
686}
687#[doc = r" Proxy"]
688pub struct _RXFIFOFIEW<'a> {
689    w: &'a mut W,
690}
691impl<'a> _RXFIFOFIEW<'a> {
692    #[doc = r" Sets the field bit"]
693    pub fn set_bit(self) -> &'a mut W {
694        self.bit(true)
695    }
696    #[doc = r" Clears the field bit"]
697    pub fn clear_bit(self) -> &'a mut W {
698        self.bit(false)
699    }
700    #[doc = r" Writes raw bits to the field"]
701    #[inline]
702    pub fn bit(self, value: bool) -> &'a mut W {
703        const MASK: bool = true;
704        const OFFSET: u8 = 17;
705        self.w.bits &= !((MASK as u32) << OFFSET);
706        self.w.bits |= ((value & MASK) as u32) << OFFSET;
707        self.w
708    }
709}
710#[doc = r" Proxy"]
711pub struct _TXFIFOFIEW<'a> {
712    w: &'a mut W,
713}
714impl<'a> _TXFIFOFIEW<'a> {
715    #[doc = r" Sets the field bit"]
716    pub fn set_bit(self) -> &'a mut W {
717        self.bit(true)
718    }
719    #[doc = r" Clears the field bit"]
720    pub fn clear_bit(self) -> &'a mut W {
721        self.bit(false)
722    }
723    #[doc = r" Writes raw bits to the field"]
724    #[inline]
725    pub fn bit(self, value: bool) -> &'a mut W {
726        const MASK: bool = true;
727        const OFFSET: u8 = 16;
728        self.w.bits &= !((MASK as u32) << OFFSET);
729        self.w.bits |= ((value & MASK) as u32) << OFFSET;
730        self.w
731    }
732}
733#[doc = r" Proxy"]
734pub struct _RXFIFOHFIEW<'a> {
735    w: &'a mut W,
736}
737impl<'a> _RXFIFOHFIEW<'a> {
738    #[doc = r" Sets the field bit"]
739    pub fn set_bit(self) -> &'a mut W {
740        self.bit(true)
741    }
742    #[doc = r" Clears the field bit"]
743    pub fn clear_bit(self) -> &'a mut W {
744        self.bit(false)
745    }
746    #[doc = r" Writes raw bits to the field"]
747    #[inline]
748    pub fn bit(self, value: bool) -> &'a mut W {
749        const MASK: bool = true;
750        const OFFSET: u8 = 15;
751        self.w.bits &= !((MASK as u32) << OFFSET);
752        self.w.bits |= ((value & MASK) as u32) << OFFSET;
753        self.w
754    }
755}
756#[doc = r" Proxy"]
757pub struct _TXFIFOHEIEW<'a> {
758    w: &'a mut W,
759}
760impl<'a> _TXFIFOHEIEW<'a> {
761    #[doc = r" Sets the field bit"]
762    pub fn set_bit(self) -> &'a mut W {
763        self.bit(true)
764    }
765    #[doc = r" Clears the field bit"]
766    pub fn clear_bit(self) -> &'a mut W {
767        self.bit(false)
768    }
769    #[doc = r" Writes raw bits to the field"]
770    #[inline]
771    pub fn bit(self, value: bool) -> &'a mut W {
772        const MASK: bool = true;
773        const OFFSET: u8 = 14;
774        self.w.bits &= !((MASK as u32) << OFFSET);
775        self.w.bits |= ((value & MASK) as u32) << OFFSET;
776        self.w
777    }
778}
779#[doc = r" Proxy"]
780pub struct _RXACTIEW<'a> {
781    w: &'a mut W,
782}
783impl<'a> _RXACTIEW<'a> {
784    #[doc = r" Sets the field bit"]
785    pub fn set_bit(self) -> &'a mut W {
786        self.bit(true)
787    }
788    #[doc = r" Clears the field bit"]
789    pub fn clear_bit(self) -> &'a mut W {
790        self.bit(false)
791    }
792    #[doc = r" Writes raw bits to the field"]
793    #[inline]
794    pub fn bit(self, value: bool) -> &'a mut W {
795        const MASK: bool = true;
796        const OFFSET: u8 = 13;
797        self.w.bits &= !((MASK as u32) << OFFSET);
798        self.w.bits |= ((value & MASK) as u32) << OFFSET;
799        self.w
800    }
801}
802#[doc = r" Proxy"]
803pub struct _TXACTIEW<'a> {
804    w: &'a mut W,
805}
806impl<'a> _TXACTIEW<'a> {
807    #[doc = r" Sets the field bit"]
808    pub fn set_bit(self) -> &'a mut W {
809        self.bit(true)
810    }
811    #[doc = r" Clears the field bit"]
812    pub fn clear_bit(self) -> &'a mut W {
813        self.bit(false)
814    }
815    #[doc = r" Writes raw bits to the field"]
816    #[inline]
817    pub fn bit(self, value: bool) -> &'a mut W {
818        const MASK: bool = true;
819        const OFFSET: u8 = 12;
820        self.w.bits &= !((MASK as u32) << OFFSET);
821        self.w.bits |= ((value & MASK) as u32) << OFFSET;
822        self.w
823    }
824}
825#[doc = r" Proxy"]
826pub struct _CMDACTIEW<'a> {
827    w: &'a mut W,
828}
829impl<'a> _CMDACTIEW<'a> {
830    #[doc = r" Sets the field bit"]
831    pub fn set_bit(self) -> &'a mut W {
832        self.bit(true)
833    }
834    #[doc = r" Clears the field bit"]
835    pub fn clear_bit(self) -> &'a mut W {
836        self.bit(false)
837    }
838    #[doc = r" Writes raw bits to the field"]
839    #[inline]
840    pub fn bit(self, value: bool) -> &'a mut W {
841        const MASK: bool = true;
842        const OFFSET: u8 = 11;
843        self.w.bits &= !((MASK as u32) << OFFSET);
844        self.w.bits |= ((value & MASK) as u32) << OFFSET;
845        self.w
846    }
847}
848#[doc = r" Proxy"]
849pub struct _DBCKENDIEW<'a> {
850    w: &'a mut W,
851}
852impl<'a> _DBCKENDIEW<'a> {
853    #[doc = r" Sets the field bit"]
854    pub fn set_bit(self) -> &'a mut W {
855        self.bit(true)
856    }
857    #[doc = r" Clears the field bit"]
858    pub fn clear_bit(self) -> &'a mut W {
859        self.bit(false)
860    }
861    #[doc = r" Writes raw bits to the field"]
862    #[inline]
863    pub fn bit(self, value: bool) -> &'a mut W {
864        const MASK: bool = true;
865        const OFFSET: u8 = 10;
866        self.w.bits &= !((MASK as u32) << OFFSET);
867        self.w.bits |= ((value & MASK) as u32) << OFFSET;
868        self.w
869    }
870}
871#[doc = r" Proxy"]
872pub struct _STBITERRIEW<'a> {
873    w: &'a mut W,
874}
875impl<'a> _STBITERRIEW<'a> {
876    #[doc = r" Sets the field bit"]
877    pub fn set_bit(self) -> &'a mut W {
878        self.bit(true)
879    }
880    #[doc = r" Clears the field bit"]
881    pub fn clear_bit(self) -> &'a mut W {
882        self.bit(false)
883    }
884    #[doc = r" Writes raw bits to the field"]
885    #[inline]
886    pub fn bit(self, value: bool) -> &'a mut W {
887        const MASK: bool = true;
888        const OFFSET: u8 = 9;
889        self.w.bits &= !((MASK as u32) << OFFSET);
890        self.w.bits |= ((value & MASK) as u32) << OFFSET;
891        self.w
892    }
893}
894#[doc = r" Proxy"]
895pub struct _DATAENDIEW<'a> {
896    w: &'a mut W,
897}
898impl<'a> _DATAENDIEW<'a> {
899    #[doc = r" Sets the field bit"]
900    pub fn set_bit(self) -> &'a mut W {
901        self.bit(true)
902    }
903    #[doc = r" Clears the field bit"]
904    pub fn clear_bit(self) -> &'a mut W {
905        self.bit(false)
906    }
907    #[doc = r" Writes raw bits to the field"]
908    #[inline]
909    pub fn bit(self, value: bool) -> &'a mut W {
910        const MASK: bool = true;
911        const OFFSET: u8 = 8;
912        self.w.bits &= !((MASK as u32) << OFFSET);
913        self.w.bits |= ((value & MASK) as u32) << OFFSET;
914        self.w
915    }
916}
917#[doc = r" Proxy"]
918pub struct _CMDSENTIEW<'a> {
919    w: &'a mut W,
920}
921impl<'a> _CMDSENTIEW<'a> {
922    #[doc = r" Sets the field bit"]
923    pub fn set_bit(self) -> &'a mut W {
924        self.bit(true)
925    }
926    #[doc = r" Clears the field bit"]
927    pub fn clear_bit(self) -> &'a mut W {
928        self.bit(false)
929    }
930    #[doc = r" Writes raw bits to the field"]
931    #[inline]
932    pub fn bit(self, value: bool) -> &'a mut W {
933        const MASK: bool = true;
934        const OFFSET: u8 = 7;
935        self.w.bits &= !((MASK as u32) << OFFSET);
936        self.w.bits |= ((value & MASK) as u32) << OFFSET;
937        self.w
938    }
939}
940#[doc = r" Proxy"]
941pub struct _CMDRENDIEW<'a> {
942    w: &'a mut W,
943}
944impl<'a> _CMDRENDIEW<'a> {
945    #[doc = r" Sets the field bit"]
946    pub fn set_bit(self) -> &'a mut W {
947        self.bit(true)
948    }
949    #[doc = r" Clears the field bit"]
950    pub fn clear_bit(self) -> &'a mut W {
951        self.bit(false)
952    }
953    #[doc = r" Writes raw bits to the field"]
954    #[inline]
955    pub fn bit(self, value: bool) -> &'a mut W {
956        const MASK: bool = true;
957        const OFFSET: u8 = 6;
958        self.w.bits &= !((MASK as u32) << OFFSET);
959        self.w.bits |= ((value & MASK) as u32) << OFFSET;
960        self.w
961    }
962}
963#[doc = r" Proxy"]
964pub struct _RXOVERRIEW<'a> {
965    w: &'a mut W,
966}
967impl<'a> _RXOVERRIEW<'a> {
968    #[doc = r" Sets the field bit"]
969    pub fn set_bit(self) -> &'a mut W {
970        self.bit(true)
971    }
972    #[doc = r" Clears the field bit"]
973    pub fn clear_bit(self) -> &'a mut W {
974        self.bit(false)
975    }
976    #[doc = r" Writes raw bits to the field"]
977    #[inline]
978    pub fn bit(self, value: bool) -> &'a mut W {
979        const MASK: bool = true;
980        const OFFSET: u8 = 5;
981        self.w.bits &= !((MASK as u32) << OFFSET);
982        self.w.bits |= ((value & MASK) as u32) << OFFSET;
983        self.w
984    }
985}
986#[doc = r" Proxy"]
987pub struct _TXUNDERRIEW<'a> {
988    w: &'a mut W,
989}
990impl<'a> _TXUNDERRIEW<'a> {
991    #[doc = r" Sets the field bit"]
992    pub fn set_bit(self) -> &'a mut W {
993        self.bit(true)
994    }
995    #[doc = r" Clears the field bit"]
996    pub fn clear_bit(self) -> &'a mut W {
997        self.bit(false)
998    }
999    #[doc = r" Writes raw bits to the field"]
1000    #[inline]
1001    pub fn bit(self, value: bool) -> &'a mut W {
1002        const MASK: bool = true;
1003        const OFFSET: u8 = 4;
1004        self.w.bits &= !((MASK as u32) << OFFSET);
1005        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1006        self.w
1007    }
1008}
1009#[doc = r" Proxy"]
1010pub struct _DTIMEOUTIEW<'a> {
1011    w: &'a mut W,
1012}
1013impl<'a> _DTIMEOUTIEW<'a> {
1014    #[doc = r" Sets the field bit"]
1015    pub fn set_bit(self) -> &'a mut W {
1016        self.bit(true)
1017    }
1018    #[doc = r" Clears the field bit"]
1019    pub fn clear_bit(self) -> &'a mut W {
1020        self.bit(false)
1021    }
1022    #[doc = r" Writes raw bits to the field"]
1023    #[inline]
1024    pub fn bit(self, value: bool) -> &'a mut W {
1025        const MASK: bool = true;
1026        const OFFSET: u8 = 3;
1027        self.w.bits &= !((MASK as u32) << OFFSET);
1028        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1029        self.w
1030    }
1031}
1032#[doc = r" Proxy"]
1033pub struct _CTIMEOUTIEW<'a> {
1034    w: &'a mut W,
1035}
1036impl<'a> _CTIMEOUTIEW<'a> {
1037    #[doc = r" Sets the field bit"]
1038    pub fn set_bit(self) -> &'a mut W {
1039        self.bit(true)
1040    }
1041    #[doc = r" Clears the field bit"]
1042    pub fn clear_bit(self) -> &'a mut W {
1043        self.bit(false)
1044    }
1045    #[doc = r" Writes raw bits to the field"]
1046    #[inline]
1047    pub fn bit(self, value: bool) -> &'a mut W {
1048        const MASK: bool = true;
1049        const OFFSET: u8 = 2;
1050        self.w.bits &= !((MASK as u32) << OFFSET);
1051        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1052        self.w
1053    }
1054}
1055#[doc = r" Proxy"]
1056pub struct _DCRCFAILIEW<'a> {
1057    w: &'a mut W,
1058}
1059impl<'a> _DCRCFAILIEW<'a> {
1060    #[doc = r" Sets the field bit"]
1061    pub fn set_bit(self) -> &'a mut W {
1062        self.bit(true)
1063    }
1064    #[doc = r" Clears the field bit"]
1065    pub fn clear_bit(self) -> &'a mut W {
1066        self.bit(false)
1067    }
1068    #[doc = r" Writes raw bits to the field"]
1069    #[inline]
1070    pub fn bit(self, value: bool) -> &'a mut W {
1071        const MASK: bool = true;
1072        const OFFSET: u8 = 1;
1073        self.w.bits &= !((MASK as u32) << OFFSET);
1074        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1075        self.w
1076    }
1077}
1078#[doc = r" Proxy"]
1079pub struct _CCRCFAILIEW<'a> {
1080    w: &'a mut W,
1081}
1082impl<'a> _CCRCFAILIEW<'a> {
1083    #[doc = r" Sets the field bit"]
1084    pub fn set_bit(self) -> &'a mut W {
1085        self.bit(true)
1086    }
1087    #[doc = r" Clears the field bit"]
1088    pub fn clear_bit(self) -> &'a mut W {
1089        self.bit(false)
1090    }
1091    #[doc = r" Writes raw bits to the field"]
1092    #[inline]
1093    pub fn bit(self, value: bool) -> &'a mut W {
1094        const MASK: bool = true;
1095        const OFFSET: u8 = 0;
1096        self.w.bits &= !((MASK as u32) << OFFSET);
1097        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1098        self.w
1099    }
1100}
1101impl R {
1102    #[doc = r" Value of the register as raw bits"]
1103    #[inline]
1104    pub fn bits(&self) -> u32 {
1105        self.bits
1106    }
1107    #[doc = "Bit 23 - CE-ATA command completion signal received interrupt enable"]
1108    #[inline]
1109    pub fn ceataendie(&self) -> CEATAENDIER {
1110        let bits = {
1111            const MASK: bool = true;
1112            const OFFSET: u8 = 23;
1113            ((self.bits >> OFFSET) & MASK as u32) != 0
1114        };
1115        CEATAENDIER { bits }
1116    }
1117    #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"]
1118    #[inline]
1119    pub fn sdioitie(&self) -> SDIOITIER {
1120        let bits = {
1121            const MASK: bool = true;
1122            const OFFSET: u8 = 22;
1123            ((self.bits >> OFFSET) & MASK as u32) != 0
1124        };
1125        SDIOITIER { bits }
1126    }
1127    #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"]
1128    #[inline]
1129    pub fn rxdavlie(&self) -> RXDAVLIER {
1130        let bits = {
1131            const MASK: bool = true;
1132            const OFFSET: u8 = 21;
1133            ((self.bits >> OFFSET) & MASK as u32) != 0
1134        };
1135        RXDAVLIER { bits }
1136    }
1137    #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"]
1138    #[inline]
1139    pub fn txdavlie(&self) -> TXDAVLIER {
1140        let bits = {
1141            const MASK: bool = true;
1142            const OFFSET: u8 = 20;
1143            ((self.bits >> OFFSET) & MASK as u32) != 0
1144        };
1145        TXDAVLIER { bits }
1146    }
1147    #[doc = "Bit 19 - Rx FIFO empty interrupt enable"]
1148    #[inline]
1149    pub fn rxfifoeie(&self) -> RXFIFOEIER {
1150        let bits = {
1151            const MASK: bool = true;
1152            const OFFSET: u8 = 19;
1153            ((self.bits >> OFFSET) & MASK as u32) != 0
1154        };
1155        RXFIFOEIER { bits }
1156    }
1157    #[doc = "Bit 18 - Tx FIFO empty interrupt enable"]
1158    #[inline]
1159    pub fn txfifoeie(&self) -> TXFIFOEIER {
1160        let bits = {
1161            const MASK: bool = true;
1162            const OFFSET: u8 = 18;
1163            ((self.bits >> OFFSET) & MASK as u32) != 0
1164        };
1165        TXFIFOEIER { bits }
1166    }
1167    #[doc = "Bit 17 - Rx FIFO full interrupt enable"]
1168    #[inline]
1169    pub fn rxfifofie(&self) -> RXFIFOFIER {
1170        let bits = {
1171            const MASK: bool = true;
1172            const OFFSET: u8 = 17;
1173            ((self.bits >> OFFSET) & MASK as u32) != 0
1174        };
1175        RXFIFOFIER { bits }
1176    }
1177    #[doc = "Bit 16 - Tx FIFO full interrupt enable"]
1178    #[inline]
1179    pub fn txfifofie(&self) -> TXFIFOFIER {
1180        let bits = {
1181            const MASK: bool = true;
1182            const OFFSET: u8 = 16;
1183            ((self.bits >> OFFSET) & MASK as u32) != 0
1184        };
1185        TXFIFOFIER { bits }
1186    }
1187    #[doc = "Bit 15 - Rx FIFO half full interrupt enable"]
1188    #[inline]
1189    pub fn rxfifohfie(&self) -> RXFIFOHFIER {
1190        let bits = {
1191            const MASK: bool = true;
1192            const OFFSET: u8 = 15;
1193            ((self.bits >> OFFSET) & MASK as u32) != 0
1194        };
1195        RXFIFOHFIER { bits }
1196    }
1197    #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"]
1198    #[inline]
1199    pub fn txfifoheie(&self) -> TXFIFOHEIER {
1200        let bits = {
1201            const MASK: bool = true;
1202            const OFFSET: u8 = 14;
1203            ((self.bits >> OFFSET) & MASK as u32) != 0
1204        };
1205        TXFIFOHEIER { bits }
1206    }
1207    #[doc = "Bit 13 - Data receive acting interrupt enable"]
1208    #[inline]
1209    pub fn rxactie(&self) -> RXACTIER {
1210        let bits = {
1211            const MASK: bool = true;
1212            const OFFSET: u8 = 13;
1213            ((self.bits >> OFFSET) & MASK as u32) != 0
1214        };
1215        RXACTIER { bits }
1216    }
1217    #[doc = "Bit 12 - Data transmit acting interrupt enable"]
1218    #[inline]
1219    pub fn txactie(&self) -> TXACTIER {
1220        let bits = {
1221            const MASK: bool = true;
1222            const OFFSET: u8 = 12;
1223            ((self.bits >> OFFSET) & MASK as u32) != 0
1224        };
1225        TXACTIER { bits }
1226    }
1227    #[doc = "Bit 11 - Command acting interrupt enable"]
1228    #[inline]
1229    pub fn cmdactie(&self) -> CMDACTIER {
1230        let bits = {
1231            const MASK: bool = true;
1232            const OFFSET: u8 = 11;
1233            ((self.bits >> OFFSET) & MASK as u32) != 0
1234        };
1235        CMDACTIER { bits }
1236    }
1237    #[doc = "Bit 10 - Data block end interrupt enable"]
1238    #[inline]
1239    pub fn dbckendie(&self) -> DBCKENDIER {
1240        let bits = {
1241            const MASK: bool = true;
1242            const OFFSET: u8 = 10;
1243            ((self.bits >> OFFSET) & MASK as u32) != 0
1244        };
1245        DBCKENDIER { bits }
1246    }
1247    #[doc = "Bit 9 - Start bit error interrupt enable"]
1248    #[inline]
1249    pub fn stbiterrie(&self) -> STBITERRIER {
1250        let bits = {
1251            const MASK: bool = true;
1252            const OFFSET: u8 = 9;
1253            ((self.bits >> OFFSET) & MASK as u32) != 0
1254        };
1255        STBITERRIER { bits }
1256    }
1257    #[doc = "Bit 8 - Data end interrupt enable"]
1258    #[inline]
1259    pub fn dataendie(&self) -> DATAENDIER {
1260        let bits = {
1261            const MASK: bool = true;
1262            const OFFSET: u8 = 8;
1263            ((self.bits >> OFFSET) & MASK as u32) != 0
1264        };
1265        DATAENDIER { bits }
1266    }
1267    #[doc = "Bit 7 - Command sent interrupt enable"]
1268    #[inline]
1269    pub fn cmdsentie(&self) -> CMDSENTIER {
1270        let bits = {
1271            const MASK: bool = true;
1272            const OFFSET: u8 = 7;
1273            ((self.bits >> OFFSET) & MASK as u32) != 0
1274        };
1275        CMDSENTIER { bits }
1276    }
1277    #[doc = "Bit 6 - Command response received interrupt enable"]
1278    #[inline]
1279    pub fn cmdrendie(&self) -> CMDRENDIER {
1280        let bits = {
1281            const MASK: bool = true;
1282            const OFFSET: u8 = 6;
1283            ((self.bits >> OFFSET) & MASK as u32) != 0
1284        };
1285        CMDRENDIER { bits }
1286    }
1287    #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"]
1288    #[inline]
1289    pub fn rxoverrie(&self) -> RXOVERRIER {
1290        let bits = {
1291            const MASK: bool = true;
1292            const OFFSET: u8 = 5;
1293            ((self.bits >> OFFSET) & MASK as u32) != 0
1294        };
1295        RXOVERRIER { bits }
1296    }
1297    #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"]
1298    #[inline]
1299    pub fn txunderrie(&self) -> TXUNDERRIER {
1300        let bits = {
1301            const MASK: bool = true;
1302            const OFFSET: u8 = 4;
1303            ((self.bits >> OFFSET) & MASK as u32) != 0
1304        };
1305        TXUNDERRIER { bits }
1306    }
1307    #[doc = "Bit 3 - Data timeout interrupt enable"]
1308    #[inline]
1309    pub fn dtimeoutie(&self) -> DTIMEOUTIER {
1310        let bits = {
1311            const MASK: bool = true;
1312            const OFFSET: u8 = 3;
1313            ((self.bits >> OFFSET) & MASK as u32) != 0
1314        };
1315        DTIMEOUTIER { bits }
1316    }
1317    #[doc = "Bit 2 - Command timeout interrupt enable"]
1318    #[inline]
1319    pub fn ctimeoutie(&self) -> CTIMEOUTIER {
1320        let bits = {
1321            const MASK: bool = true;
1322            const OFFSET: u8 = 2;
1323            ((self.bits >> OFFSET) & MASK as u32) != 0
1324        };
1325        CTIMEOUTIER { bits }
1326    }
1327    #[doc = "Bit 1 - Data CRC fail interrupt enable"]
1328    #[inline]
1329    pub fn dcrcfailie(&self) -> DCRCFAILIER {
1330        let bits = {
1331            const MASK: bool = true;
1332            const OFFSET: u8 = 1;
1333            ((self.bits >> OFFSET) & MASK as u32) != 0
1334        };
1335        DCRCFAILIER { bits }
1336    }
1337    #[doc = "Bit 0 - Command CRC fail interrupt enable"]
1338    #[inline]
1339    pub fn ccrcfailie(&self) -> CCRCFAILIER {
1340        let bits = {
1341            const MASK: bool = true;
1342            const OFFSET: u8 = 0;
1343            ((self.bits >> OFFSET) & MASK as u32) != 0
1344        };
1345        CCRCFAILIER { bits }
1346    }
1347}
1348impl W {
1349    #[doc = r" Reset value of the register"]
1350    #[inline]
1351    pub fn reset_value() -> W {
1352        W { bits: 0 }
1353    }
1354    #[doc = r" Writes raw bits to the register"]
1355    #[inline]
1356    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1357        self.bits = bits;
1358        self
1359    }
1360    #[doc = "Bit 23 - CE-ATA command completion signal received interrupt enable"]
1361    #[inline]
1362    pub fn ceataendie(&mut self) -> _CEATAENDIEW {
1363        _CEATAENDIEW { w: self }
1364    }
1365    #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"]
1366    #[inline]
1367    pub fn sdioitie(&mut self) -> _SDIOITIEW {
1368        _SDIOITIEW { w: self }
1369    }
1370    #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"]
1371    #[inline]
1372    pub fn rxdavlie(&mut self) -> _RXDAVLIEW {
1373        _RXDAVLIEW { w: self }
1374    }
1375    #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"]
1376    #[inline]
1377    pub fn txdavlie(&mut self) -> _TXDAVLIEW {
1378        _TXDAVLIEW { w: self }
1379    }
1380    #[doc = "Bit 19 - Rx FIFO empty interrupt enable"]
1381    #[inline]
1382    pub fn rxfifoeie(&mut self) -> _RXFIFOEIEW {
1383        _RXFIFOEIEW { w: self }
1384    }
1385    #[doc = "Bit 18 - Tx FIFO empty interrupt enable"]
1386    #[inline]
1387    pub fn txfifoeie(&mut self) -> _TXFIFOEIEW {
1388        _TXFIFOEIEW { w: self }
1389    }
1390    #[doc = "Bit 17 - Rx FIFO full interrupt enable"]
1391    #[inline]
1392    pub fn rxfifofie(&mut self) -> _RXFIFOFIEW {
1393        _RXFIFOFIEW { w: self }
1394    }
1395    #[doc = "Bit 16 - Tx FIFO full interrupt enable"]
1396    #[inline]
1397    pub fn txfifofie(&mut self) -> _TXFIFOFIEW {
1398        _TXFIFOFIEW { w: self }
1399    }
1400    #[doc = "Bit 15 - Rx FIFO half full interrupt enable"]
1401    #[inline]
1402    pub fn rxfifohfie(&mut self) -> _RXFIFOHFIEW {
1403        _RXFIFOHFIEW { w: self }
1404    }
1405    #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"]
1406    #[inline]
1407    pub fn txfifoheie(&mut self) -> _TXFIFOHEIEW {
1408        _TXFIFOHEIEW { w: self }
1409    }
1410    #[doc = "Bit 13 - Data receive acting interrupt enable"]
1411    #[inline]
1412    pub fn rxactie(&mut self) -> _RXACTIEW {
1413        _RXACTIEW { w: self }
1414    }
1415    #[doc = "Bit 12 - Data transmit acting interrupt enable"]
1416    #[inline]
1417    pub fn txactie(&mut self) -> _TXACTIEW {
1418        _TXACTIEW { w: self }
1419    }
1420    #[doc = "Bit 11 - Command acting interrupt enable"]
1421    #[inline]
1422    pub fn cmdactie(&mut self) -> _CMDACTIEW {
1423        _CMDACTIEW { w: self }
1424    }
1425    #[doc = "Bit 10 - Data block end interrupt enable"]
1426    #[inline]
1427    pub fn dbckendie(&mut self) -> _DBCKENDIEW {
1428        _DBCKENDIEW { w: self }
1429    }
1430    #[doc = "Bit 9 - Start bit error interrupt enable"]
1431    #[inline]
1432    pub fn stbiterrie(&mut self) -> _STBITERRIEW {
1433        _STBITERRIEW { w: self }
1434    }
1435    #[doc = "Bit 8 - Data end interrupt enable"]
1436    #[inline]
1437    pub fn dataendie(&mut self) -> _DATAENDIEW {
1438        _DATAENDIEW { w: self }
1439    }
1440    #[doc = "Bit 7 - Command sent interrupt enable"]
1441    #[inline]
1442    pub fn cmdsentie(&mut self) -> _CMDSENTIEW {
1443        _CMDSENTIEW { w: self }
1444    }
1445    #[doc = "Bit 6 - Command response received interrupt enable"]
1446    #[inline]
1447    pub fn cmdrendie(&mut self) -> _CMDRENDIEW {
1448        _CMDRENDIEW { w: self }
1449    }
1450    #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"]
1451    #[inline]
1452    pub fn rxoverrie(&mut self) -> _RXOVERRIEW {
1453        _RXOVERRIEW { w: self }
1454    }
1455    #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"]
1456    #[inline]
1457    pub fn txunderrie(&mut self) -> _TXUNDERRIEW {
1458        _TXUNDERRIEW { w: self }
1459    }
1460    #[doc = "Bit 3 - Data timeout interrupt enable"]
1461    #[inline]
1462    pub fn dtimeoutie(&mut self) -> _DTIMEOUTIEW {
1463        _DTIMEOUTIEW { w: self }
1464    }
1465    #[doc = "Bit 2 - Command timeout interrupt enable"]
1466    #[inline]
1467    pub fn ctimeoutie(&mut self) -> _CTIMEOUTIEW {
1468        _CTIMEOUTIEW { w: self }
1469    }
1470    #[doc = "Bit 1 - Data CRC fail interrupt enable"]
1471    #[inline]
1472    pub fn dcrcfailie(&mut self) -> _DCRCFAILIEW {
1473        _DCRCFAILIEW { w: self }
1474    }
1475    #[doc = "Bit 0 - Command CRC fail interrupt enable"]
1476    #[inline]
1477    pub fn ccrcfailie(&mut self) -> _CCRCFAILIEW {
1478        _CCRCFAILIEW { w: self }
1479    }
1480}
stm32l4x2_pac/sdmmc/mask.rs

stm32l4x2_pac/sdmmc/
mask.rs
