stm32f429/ethernet_dma/
dmaier.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::DMAIER {
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 TIER {
47    bits: bool,
48}
49impl TIER {
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 TPSIER {
68    bits: bool,
69}
70impl TPSIER {
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 TBUIER {
89    bits: bool,
90}
91impl TBUIER {
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 TJTIER {
110    bits: bool,
111}
112impl TJTIER {
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 ROIER {
131    bits: bool,
132}
133impl ROIER {
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 TUIER {
152    bits: bool,
153}
154impl TUIER {
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 RIER {
173    bits: bool,
174}
175impl RIER {
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 RBUIER {
194    bits: bool,
195}
196impl RBUIER {
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 RPSIER {
215    bits: bool,
216}
217impl RPSIER {
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 RWTIER {
236    bits: bool,
237}
238impl RWTIER {
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 ETIER {
257    bits: bool,
258}
259impl ETIER {
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 FBEIER {
278    bits: bool,
279}
280impl FBEIER {
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 ERIER {
299    bits: bool,
300}
301impl ERIER {
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 AISER {
320    bits: bool,
321}
322impl AISER {
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 NISER {
341    bits: bool,
342}
343impl NISER {
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" Proxy"]
361pub struct _TIEW<'a> {
362    w: &'a mut W,
363}
364impl<'a> _TIEW<'a> {
365    #[doc = r" Sets the field bit"]
366    pub fn set_bit(self) -> &'a mut W {
367        self.bit(true)
368    }
369    #[doc = r" Clears the field bit"]
370    pub fn clear_bit(self) -> &'a mut W {
371        self.bit(false)
372    }
373    #[doc = r" Writes raw bits to the field"]
374    #[inline]
375    pub fn bit(self, value: bool) -> &'a mut W {
376        const MASK: bool = true;
377        const OFFSET: u8 = 0;
378        self.w.bits &= !((MASK as u32) << OFFSET);
379        self.w.bits |= ((value & MASK) as u32) << OFFSET;
380        self.w
381    }
382}
383#[doc = r" Proxy"]
384pub struct _TPSIEW<'a> {
385    w: &'a mut W,
386}
387impl<'a> _TPSIEW<'a> {
388    #[doc = r" Sets the field bit"]
389    pub fn set_bit(self) -> &'a mut W {
390        self.bit(true)
391    }
392    #[doc = r" Clears the field bit"]
393    pub fn clear_bit(self) -> &'a mut W {
394        self.bit(false)
395    }
396    #[doc = r" Writes raw bits to the field"]
397    #[inline]
398    pub fn bit(self, value: bool) -> &'a mut W {
399        const MASK: bool = true;
400        const OFFSET: u8 = 1;
401        self.w.bits &= !((MASK as u32) << OFFSET);
402        self.w.bits |= ((value & MASK) as u32) << OFFSET;
403        self.w
404    }
405}
406#[doc = r" Proxy"]
407pub struct _TBUIEW<'a> {
408    w: &'a mut W,
409}
410impl<'a> _TBUIEW<'a> {
411    #[doc = r" Sets the field bit"]
412    pub fn set_bit(self) -> &'a mut W {
413        self.bit(true)
414    }
415    #[doc = r" Clears the field bit"]
416    pub fn clear_bit(self) -> &'a mut W {
417        self.bit(false)
418    }
419    #[doc = r" Writes raw bits to the field"]
420    #[inline]
421    pub fn bit(self, value: bool) -> &'a mut W {
422        const MASK: bool = true;
423        const OFFSET: u8 = 2;
424        self.w.bits &= !((MASK as u32) << OFFSET);
425        self.w.bits |= ((value & MASK) as u32) << OFFSET;
426        self.w
427    }
428}
429#[doc = r" Proxy"]
430pub struct _TJTIEW<'a> {
431    w: &'a mut W,
432}
433impl<'a> _TJTIEW<'a> {
434    #[doc = r" Sets the field bit"]
435    pub fn set_bit(self) -> &'a mut W {
436        self.bit(true)
437    }
438    #[doc = r" Clears the field bit"]
439    pub fn clear_bit(self) -> &'a mut W {
440        self.bit(false)
441    }
442    #[doc = r" Writes raw bits to the field"]
443    #[inline]
444    pub fn bit(self, value: bool) -> &'a mut W {
445        const MASK: bool = true;
446        const OFFSET: u8 = 3;
447        self.w.bits &= !((MASK as u32) << OFFSET);
448        self.w.bits |= ((value & MASK) as u32) << OFFSET;
449        self.w
450    }
451}
452#[doc = r" Proxy"]
453pub struct _ROIEW<'a> {
454    w: &'a mut W,
455}
456impl<'a> _ROIEW<'a> {
457    #[doc = r" Sets the field bit"]
458    pub fn set_bit(self) -> &'a mut W {
459        self.bit(true)
460    }
461    #[doc = r" Clears the field bit"]
462    pub fn clear_bit(self) -> &'a mut W {
463        self.bit(false)
464    }
465    #[doc = r" Writes raw bits to the field"]
466    #[inline]
467    pub fn bit(self, value: bool) -> &'a mut W {
468        const MASK: bool = true;
469        const OFFSET: u8 = 4;
470        self.w.bits &= !((MASK as u32) << OFFSET);
471        self.w.bits |= ((value & MASK) as u32) << OFFSET;
472        self.w
473    }
474}
475#[doc = r" Proxy"]
476pub struct _TUIEW<'a> {
477    w: &'a mut W,
478}
479impl<'a> _TUIEW<'a> {
480    #[doc = r" Sets the field bit"]
481    pub fn set_bit(self) -> &'a mut W {
482        self.bit(true)
483    }
484    #[doc = r" Clears the field bit"]
485    pub fn clear_bit(self) -> &'a mut W {
486        self.bit(false)
487    }
488    #[doc = r" Writes raw bits to the field"]
489    #[inline]
490    pub fn bit(self, value: bool) -> &'a mut W {
491        const MASK: bool = true;
492        const OFFSET: u8 = 5;
493        self.w.bits &= !((MASK as u32) << OFFSET);
494        self.w.bits |= ((value & MASK) as u32) << OFFSET;
495        self.w
496    }
497}
498#[doc = r" Proxy"]
499pub struct _RIEW<'a> {
500    w: &'a mut W,
501}
502impl<'a> _RIEW<'a> {
503    #[doc = r" Sets the field bit"]
504    pub fn set_bit(self) -> &'a mut W {
505        self.bit(true)
506    }
507    #[doc = r" Clears the field bit"]
508    pub fn clear_bit(self) -> &'a mut W {
509        self.bit(false)
510    }
511    #[doc = r" Writes raw bits to the field"]
512    #[inline]
513    pub fn bit(self, value: bool) -> &'a mut W {
514        const MASK: bool = true;
515        const OFFSET: u8 = 6;
516        self.w.bits &= !((MASK as u32) << OFFSET);
517        self.w.bits |= ((value & MASK) as u32) << OFFSET;
518        self.w
519    }
520}
521#[doc = r" Proxy"]
522pub struct _RBUIEW<'a> {
523    w: &'a mut W,
524}
525impl<'a> _RBUIEW<'a> {
526    #[doc = r" Sets the field bit"]
527    pub fn set_bit(self) -> &'a mut W {
528        self.bit(true)
529    }
530    #[doc = r" Clears the field bit"]
531    pub fn clear_bit(self) -> &'a mut W {
532        self.bit(false)
533    }
534    #[doc = r" Writes raw bits to the field"]
535    #[inline]
536    pub fn bit(self, value: bool) -> &'a mut W {
537        const MASK: bool = true;
538        const OFFSET: u8 = 7;
539        self.w.bits &= !((MASK as u32) << OFFSET);
540        self.w.bits |= ((value & MASK) as u32) << OFFSET;
541        self.w
542    }
543}
544#[doc = r" Proxy"]
545pub struct _RPSIEW<'a> {
546    w: &'a mut W,
547}
548impl<'a> _RPSIEW<'a> {
549    #[doc = r" Sets the field bit"]
550    pub fn set_bit(self) -> &'a mut W {
551        self.bit(true)
552    }
553    #[doc = r" Clears the field bit"]
554    pub fn clear_bit(self) -> &'a mut W {
555        self.bit(false)
556    }
557    #[doc = r" Writes raw bits to the field"]
558    #[inline]
559    pub fn bit(self, value: bool) -> &'a mut W {
560        const MASK: bool = true;
561        const OFFSET: u8 = 8;
562        self.w.bits &= !((MASK as u32) << OFFSET);
563        self.w.bits |= ((value & MASK) as u32) << OFFSET;
564        self.w
565    }
566}
567#[doc = r" Proxy"]
568pub struct _RWTIEW<'a> {
569    w: &'a mut W,
570}
571impl<'a> _RWTIEW<'a> {
572    #[doc = r" Sets the field bit"]
573    pub fn set_bit(self) -> &'a mut W {
574        self.bit(true)
575    }
576    #[doc = r" Clears the field bit"]
577    pub fn clear_bit(self) -> &'a mut W {
578        self.bit(false)
579    }
580    #[doc = r" Writes raw bits to the field"]
581    #[inline]
582    pub fn bit(self, value: bool) -> &'a mut W {
583        const MASK: bool = true;
584        const OFFSET: u8 = 9;
585        self.w.bits &= !((MASK as u32) << OFFSET);
586        self.w.bits |= ((value & MASK) as u32) << OFFSET;
587        self.w
588    }
589}
590#[doc = r" Proxy"]
591pub struct _ETIEW<'a> {
592    w: &'a mut W,
593}
594impl<'a> _ETIEW<'a> {
595    #[doc = r" Sets the field bit"]
596    pub fn set_bit(self) -> &'a mut W {
597        self.bit(true)
598    }
599    #[doc = r" Clears the field bit"]
600    pub fn clear_bit(self) -> &'a mut W {
601        self.bit(false)
602    }
603    #[doc = r" Writes raw bits to the field"]
604    #[inline]
605    pub fn bit(self, value: bool) -> &'a mut W {
606        const MASK: bool = true;
607        const OFFSET: u8 = 10;
608        self.w.bits &= !((MASK as u32) << OFFSET);
609        self.w.bits |= ((value & MASK) as u32) << OFFSET;
610        self.w
611    }
612}
613#[doc = r" Proxy"]
614pub struct _FBEIEW<'a> {
615    w: &'a mut W,
616}
617impl<'a> _FBEIEW<'a> {
618    #[doc = r" Sets the field bit"]
619    pub fn set_bit(self) -> &'a mut W {
620        self.bit(true)
621    }
622    #[doc = r" Clears the field bit"]
623    pub fn clear_bit(self) -> &'a mut W {
624        self.bit(false)
625    }
626    #[doc = r" Writes raw bits to the field"]
627    #[inline]
628    pub fn bit(self, value: bool) -> &'a mut W {
629        const MASK: bool = true;
630        const OFFSET: u8 = 13;
631        self.w.bits &= !((MASK as u32) << OFFSET);
632        self.w.bits |= ((value & MASK) as u32) << OFFSET;
633        self.w
634    }
635}
636#[doc = r" Proxy"]
637pub struct _ERIEW<'a> {
638    w: &'a mut W,
639}
640impl<'a> _ERIEW<'a> {
641    #[doc = r" Sets the field bit"]
642    pub fn set_bit(self) -> &'a mut W {
643        self.bit(true)
644    }
645    #[doc = r" Clears the field bit"]
646    pub fn clear_bit(self) -> &'a mut W {
647        self.bit(false)
648    }
649    #[doc = r" Writes raw bits to the field"]
650    #[inline]
651    pub fn bit(self, value: bool) -> &'a mut W {
652        const MASK: bool = true;
653        const OFFSET: u8 = 14;
654        self.w.bits &= !((MASK as u32) << OFFSET);
655        self.w.bits |= ((value & MASK) as u32) << OFFSET;
656        self.w
657    }
658}
659#[doc = r" Proxy"]
660pub struct _AISEW<'a> {
661    w: &'a mut W,
662}
663impl<'a> _AISEW<'a> {
664    #[doc = r" Sets the field bit"]
665    pub fn set_bit(self) -> &'a mut W {
666        self.bit(true)
667    }
668    #[doc = r" Clears the field bit"]
669    pub fn clear_bit(self) -> &'a mut W {
670        self.bit(false)
671    }
672    #[doc = r" Writes raw bits to the field"]
673    #[inline]
674    pub fn bit(self, value: bool) -> &'a mut W {
675        const MASK: bool = true;
676        const OFFSET: u8 = 15;
677        self.w.bits &= !((MASK as u32) << OFFSET);
678        self.w.bits |= ((value & MASK) as u32) << OFFSET;
679        self.w
680    }
681}
682#[doc = r" Proxy"]
683pub struct _NISEW<'a> {
684    w: &'a mut W,
685}
686impl<'a> _NISEW<'a> {
687    #[doc = r" Sets the field bit"]
688    pub fn set_bit(self) -> &'a mut W {
689        self.bit(true)
690    }
691    #[doc = r" Clears the field bit"]
692    pub fn clear_bit(self) -> &'a mut W {
693        self.bit(false)
694    }
695    #[doc = r" Writes raw bits to the field"]
696    #[inline]
697    pub fn bit(self, value: bool) -> &'a mut W {
698        const MASK: bool = true;
699        const OFFSET: u8 = 16;
700        self.w.bits &= !((MASK as u32) << OFFSET);
701        self.w.bits |= ((value & MASK) as u32) << OFFSET;
702        self.w
703    }
704}
705impl R {
706    #[doc = r" Value of the register as raw bits"]
707    #[inline]
708    pub fn bits(&self) -> u32 {
709        self.bits
710    }
711    #[doc = "Bit 0 - TIE"]
712    #[inline]
713    pub fn tie(&self) -> TIER {
714        let bits = {
715            const MASK: bool = true;
716            const OFFSET: u8 = 0;
717            ((self.bits >> OFFSET) & MASK as u32) != 0
718        };
719        TIER { bits }
720    }
721    #[doc = "Bit 1 - TPSIE"]
722    #[inline]
723    pub fn tpsie(&self) -> TPSIER {
724        let bits = {
725            const MASK: bool = true;
726            const OFFSET: u8 = 1;
727            ((self.bits >> OFFSET) & MASK as u32) != 0
728        };
729        TPSIER { bits }
730    }
731    #[doc = "Bit 2 - TBUIE"]
732    #[inline]
733    pub fn tbuie(&self) -> TBUIER {
734        let bits = {
735            const MASK: bool = true;
736            const OFFSET: u8 = 2;
737            ((self.bits >> OFFSET) & MASK as u32) != 0
738        };
739        TBUIER { bits }
740    }
741    #[doc = "Bit 3 - TJTIE"]
742    #[inline]
743    pub fn tjtie(&self) -> TJTIER {
744        let bits = {
745            const MASK: bool = true;
746            const OFFSET: u8 = 3;
747            ((self.bits >> OFFSET) & MASK as u32) != 0
748        };
749        TJTIER { bits }
750    }
751    #[doc = "Bit 4 - ROIE"]
752    #[inline]
753    pub fn roie(&self) -> ROIER {
754        let bits = {
755            const MASK: bool = true;
756            const OFFSET: u8 = 4;
757            ((self.bits >> OFFSET) & MASK as u32) != 0
758        };
759        ROIER { bits }
760    }
761    #[doc = "Bit 5 - TUIE"]
762    #[inline]
763    pub fn tuie(&self) -> TUIER {
764        let bits = {
765            const MASK: bool = true;
766            const OFFSET: u8 = 5;
767            ((self.bits >> OFFSET) & MASK as u32) != 0
768        };
769        TUIER { bits }
770    }
771    #[doc = "Bit 6 - RIE"]
772    #[inline]
773    pub fn rie(&self) -> RIER {
774        let bits = {
775            const MASK: bool = true;
776            const OFFSET: u8 = 6;
777            ((self.bits >> OFFSET) & MASK as u32) != 0
778        };
779        RIER { bits }
780    }
781    #[doc = "Bit 7 - RBUIE"]
782    #[inline]
783    pub fn rbuie(&self) -> RBUIER {
784        let bits = {
785            const MASK: bool = true;
786            const OFFSET: u8 = 7;
787            ((self.bits >> OFFSET) & MASK as u32) != 0
788        };
789        RBUIER { bits }
790    }
791    #[doc = "Bit 8 - RPSIE"]
792    #[inline]
793    pub fn rpsie(&self) -> RPSIER {
794        let bits = {
795            const MASK: bool = true;
796            const OFFSET: u8 = 8;
797            ((self.bits >> OFFSET) & MASK as u32) != 0
798        };
799        RPSIER { bits }
800    }
801    #[doc = "Bit 9 - RWTIE"]
802    #[inline]
803    pub fn rwtie(&self) -> RWTIER {
804        let bits = {
805            const MASK: bool = true;
806            const OFFSET: u8 = 9;
807            ((self.bits >> OFFSET) & MASK as u32) != 0
808        };
809        RWTIER { bits }
810    }
811    #[doc = "Bit 10 - ETIE"]
812    #[inline]
813    pub fn etie(&self) -> ETIER {
814        let bits = {
815            const MASK: bool = true;
816            const OFFSET: u8 = 10;
817            ((self.bits >> OFFSET) & MASK as u32) != 0
818        };
819        ETIER { bits }
820    }
821    #[doc = "Bit 13 - FBEIE"]
822    #[inline]
823    pub fn fbeie(&self) -> FBEIER {
824        let bits = {
825            const MASK: bool = true;
826            const OFFSET: u8 = 13;
827            ((self.bits >> OFFSET) & MASK as u32) != 0
828        };
829        FBEIER { bits }
830    }
831    #[doc = "Bit 14 - ERIE"]
832    #[inline]
833    pub fn erie(&self) -> ERIER {
834        let bits = {
835            const MASK: bool = true;
836            const OFFSET: u8 = 14;
837            ((self.bits >> OFFSET) & MASK as u32) != 0
838        };
839        ERIER { bits }
840    }
841    #[doc = "Bit 15 - AISE"]
842    #[inline]
843    pub fn aise(&self) -> AISER {
844        let bits = {
845            const MASK: bool = true;
846            const OFFSET: u8 = 15;
847            ((self.bits >> OFFSET) & MASK as u32) != 0
848        };
849        AISER { bits }
850    }
851    #[doc = "Bit 16 - NISE"]
852    #[inline]
853    pub fn nise(&self) -> NISER {
854        let bits = {
855            const MASK: bool = true;
856            const OFFSET: u8 = 16;
857            ((self.bits >> OFFSET) & MASK as u32) != 0
858        };
859        NISER { bits }
860    }
861}
862impl W {
863    #[doc = r" Reset value of the register"]
864    #[inline]
865    pub fn reset_value() -> W {
866        W { bits: 0 }
867    }
868    #[doc = r" Writes raw bits to the register"]
869    #[inline]
870    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
871        self.bits = bits;
872        self
873    }
874    #[doc = "Bit 0 - TIE"]
875    #[inline]
876    pub fn tie(&mut self) -> _TIEW {
877        _TIEW { w: self }
878    }
879    #[doc = "Bit 1 - TPSIE"]
880    #[inline]
881    pub fn tpsie(&mut self) -> _TPSIEW {
882        _TPSIEW { w: self }
883    }
884    #[doc = "Bit 2 - TBUIE"]
885    #[inline]
886    pub fn tbuie(&mut self) -> _TBUIEW {
887        _TBUIEW { w: self }
888    }
889    #[doc = "Bit 3 - TJTIE"]
890    #[inline]
891    pub fn tjtie(&mut self) -> _TJTIEW {
892        _TJTIEW { w: self }
893    }
894    #[doc = "Bit 4 - ROIE"]
895    #[inline]
896    pub fn roie(&mut self) -> _ROIEW {
897        _ROIEW { w: self }
898    }
899    #[doc = "Bit 5 - TUIE"]
900    #[inline]
901    pub fn tuie(&mut self) -> _TUIEW {
902        _TUIEW { w: self }
903    }
904    #[doc = "Bit 6 - RIE"]
905    #[inline]
906    pub fn rie(&mut self) -> _RIEW {
907        _RIEW { w: self }
908    }
909    #[doc = "Bit 7 - RBUIE"]
910    #[inline]
911    pub fn rbuie(&mut self) -> _RBUIEW {
912        _RBUIEW { w: self }
913    }
914    #[doc = "Bit 8 - RPSIE"]
915    #[inline]
916    pub fn rpsie(&mut self) -> _RPSIEW {
917        _RPSIEW { w: self }
918    }
919    #[doc = "Bit 9 - RWTIE"]
920    #[inline]
921    pub fn rwtie(&mut self) -> _RWTIEW {
922        _RWTIEW { w: self }
923    }
924    #[doc = "Bit 10 - ETIE"]
925    #[inline]
926    pub fn etie(&mut self) -> _ETIEW {
927        _ETIEW { w: self }
928    }
929    #[doc = "Bit 13 - FBEIE"]
930    #[inline]
931    pub fn fbeie(&mut self) -> _FBEIEW {
932        _FBEIEW { w: self }
933    }
934    #[doc = "Bit 14 - ERIE"]
935    #[inline]
936    pub fn erie(&mut self) -> _ERIEW {
937        _ERIEW { w: self }
938    }
939    #[doc = "Bit 15 - AISE"]
940    #[inline]
941    pub fn aise(&mut self) -> _AISEW {
942        _AISEW { w: self }
943    }
944    #[doc = "Bit 16 - NISE"]
945    #[inline]
946    pub fn nise(&mut self) -> _NISEW {
947        _NISEW { w: self }
948    }
949}
stm32f429/ethernet_dma/dmaier.rs

stm32f429/ethernet_dma/
dmaier.rs
