stm32l4x2_pac/dma1/
ifcr.rs

1#[doc = r" Value to write to the register"]
2pub struct W {
3    bits: u32,
4}
5impl super::IFCR {
6    #[doc = r" Writes to the register"]
7    #[inline]
8    pub fn write<F>(&self, f: F)
9    where
10        F: FnOnce(&mut W) -> &mut W,
11    {
12        let mut w = W::reset_value();
13        f(&mut w);
14        self.register.set(w.bits);
15    }
16}
17#[doc = "Values that can be written to the field `CTEIF7`"]
18pub enum CTEIF7W {
19    #[doc = "Clears the TEIF flag in the ISR register"]
20    CLEAR,
21}
22impl CTEIF7W {
23    #[allow(missing_docs)]
24    #[doc(hidden)]
25    #[inline]
26    pub fn _bits(&self) -> bool {
27        match *self {
28            CTEIF7W::CLEAR => true,
29        }
30    }
31}
32#[doc = r" Proxy"]
33pub struct _CTEIF7W<'a> {
34    w: &'a mut W,
35}
36impl<'a> _CTEIF7W<'a> {
37    #[doc = r" Writes `variant` to the field"]
38    #[inline]
39    pub fn variant(self, variant: CTEIF7W) -> &'a mut W {
40        {
41            self.bit(variant._bits())
42        }
43    }
44    #[doc = "Clears the TEIF flag in the ISR register"]
45    #[inline]
46    pub fn clear(self) -> &'a mut W {
47        self.variant(CTEIF7W::CLEAR)
48    }
49    #[doc = r" Sets the field bit"]
50    pub fn set_bit(self) -> &'a mut W {
51        self.bit(true)
52    }
53    #[doc = r" Clears the field bit"]
54    pub fn clear_bit(self) -> &'a mut W {
55        self.bit(false)
56    }
57    #[doc = r" Writes raw bits to the field"]
58    #[inline]
59    pub fn bit(self, value: bool) -> &'a mut W {
60        const MASK: bool = true;
61        const OFFSET: u8 = 27;
62        self.w.bits &= !((MASK as u32) << OFFSET);
63        self.w.bits |= ((value & MASK) as u32) << OFFSET;
64        self.w
65    }
66}
67#[doc = "Values that can be written to the field `CHTIF7`"]
68pub enum CHTIF7W {
69    #[doc = "Clears the HTIF flag in the ISR register"]
70    CLEAR,
71}
72impl CHTIF7W {
73    #[allow(missing_docs)]
74    #[doc(hidden)]
75    #[inline]
76    pub fn _bits(&self) -> bool {
77        match *self {
78            CHTIF7W::CLEAR => true,
79        }
80    }
81}
82#[doc = r" Proxy"]
83pub struct _CHTIF7W<'a> {
84    w: &'a mut W,
85}
86impl<'a> _CHTIF7W<'a> {
87    #[doc = r" Writes `variant` to the field"]
88    #[inline]
89    pub fn variant(self, variant: CHTIF7W) -> &'a mut W {
90        {
91            self.bit(variant._bits())
92        }
93    }
94    #[doc = "Clears the HTIF flag in the ISR register"]
95    #[inline]
96    pub fn clear(self) -> &'a mut W {
97        self.variant(CHTIF7W::CLEAR)
98    }
99    #[doc = r" Sets the field bit"]
100    pub fn set_bit(self) -> &'a mut W {
101        self.bit(true)
102    }
103    #[doc = r" Clears the field bit"]
104    pub fn clear_bit(self) -> &'a mut W {
105        self.bit(false)
106    }
107    #[doc = r" Writes raw bits to the field"]
108    #[inline]
109    pub fn bit(self, value: bool) -> &'a mut W {
110        const MASK: bool = true;
111        const OFFSET: u8 = 26;
112        self.w.bits &= !((MASK as u32) << OFFSET);
113        self.w.bits |= ((value & MASK) as u32) << OFFSET;
114        self.w
115    }
116}
117#[doc = "Values that can be written to the field `CTCIF7`"]
118pub enum CTCIF7W {
119    #[doc = "Clears the TCIF flag in the ISR register"]
120    CLEAR,
121}
122impl CTCIF7W {
123    #[allow(missing_docs)]
124    #[doc(hidden)]
125    #[inline]
126    pub fn _bits(&self) -> bool {
127        match *self {
128            CTCIF7W::CLEAR => true,
129        }
130    }
131}
132#[doc = r" Proxy"]
133pub struct _CTCIF7W<'a> {
134    w: &'a mut W,
135}
136impl<'a> _CTCIF7W<'a> {
137    #[doc = r" Writes `variant` to the field"]
138    #[inline]
139    pub fn variant(self, variant: CTCIF7W) -> &'a mut W {
140        {
141            self.bit(variant._bits())
142        }
143    }
144    #[doc = "Clears the TCIF flag in the ISR register"]
145    #[inline]
146    pub fn clear(self) -> &'a mut W {
147        self.variant(CTCIF7W::CLEAR)
148    }
149    #[doc = r" Sets the field bit"]
150    pub fn set_bit(self) -> &'a mut W {
151        self.bit(true)
152    }
153    #[doc = r" Clears the field bit"]
154    pub fn clear_bit(self) -> &'a mut W {
155        self.bit(false)
156    }
157    #[doc = r" Writes raw bits to the field"]
158    #[inline]
159    pub fn bit(self, value: bool) -> &'a mut W {
160        const MASK: bool = true;
161        const OFFSET: u8 = 25;
162        self.w.bits &= !((MASK as u32) << OFFSET);
163        self.w.bits |= ((value & MASK) as u32) << OFFSET;
164        self.w
165    }
166}
167#[doc = "Values that can be written to the field `CGIF7`"]
168pub enum CGIF7W {
169    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
170    CLEAR,
171}
172impl CGIF7W {
173    #[allow(missing_docs)]
174    #[doc(hidden)]
175    #[inline]
176    pub fn _bits(&self) -> bool {
177        match *self {
178            CGIF7W::CLEAR => true,
179        }
180    }
181}
182#[doc = r" Proxy"]
183pub struct _CGIF7W<'a> {
184    w: &'a mut W,
185}
186impl<'a> _CGIF7W<'a> {
187    #[doc = r" Writes `variant` to the field"]
188    #[inline]
189    pub fn variant(self, variant: CGIF7W) -> &'a mut W {
190        {
191            self.bit(variant._bits())
192        }
193    }
194    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
195    #[inline]
196    pub fn clear(self) -> &'a mut W {
197        self.variant(CGIF7W::CLEAR)
198    }
199    #[doc = r" Sets the field bit"]
200    pub fn set_bit(self) -> &'a mut W {
201        self.bit(true)
202    }
203    #[doc = r" Clears the field bit"]
204    pub fn clear_bit(self) -> &'a mut W {
205        self.bit(false)
206    }
207    #[doc = r" Writes raw bits to the field"]
208    #[inline]
209    pub fn bit(self, value: bool) -> &'a mut W {
210        const MASK: bool = true;
211        const OFFSET: u8 = 24;
212        self.w.bits &= !((MASK as u32) << OFFSET);
213        self.w.bits |= ((value & MASK) as u32) << OFFSET;
214        self.w
215    }
216}
217#[doc = "Values that can be written to the field `CTEIF6`"]
218pub type CTEIF6W = CTEIF7W;
219#[doc = r" Proxy"]
220pub struct _CTEIF6W<'a> {
221    w: &'a mut W,
222}
223impl<'a> _CTEIF6W<'a> {
224    #[doc = r" Writes `variant` to the field"]
225    #[inline]
226    pub fn variant(self, variant: CTEIF6W) -> &'a mut W {
227        {
228            self.bit(variant._bits())
229        }
230    }
231    #[doc = "Clears the TEIF flag in the ISR register"]
232    #[inline]
233    pub fn clear(self) -> &'a mut W {
234        self.variant(CTEIF7W::CLEAR)
235    }
236    #[doc = r" Sets the field bit"]
237    pub fn set_bit(self) -> &'a mut W {
238        self.bit(true)
239    }
240    #[doc = r" Clears the field bit"]
241    pub fn clear_bit(self) -> &'a mut W {
242        self.bit(false)
243    }
244    #[doc = r" Writes raw bits to the field"]
245    #[inline]
246    pub fn bit(self, value: bool) -> &'a mut W {
247        const MASK: bool = true;
248        const OFFSET: u8 = 23;
249        self.w.bits &= !((MASK as u32) << OFFSET);
250        self.w.bits |= ((value & MASK) as u32) << OFFSET;
251        self.w
252    }
253}
254#[doc = "Values that can be written to the field `CHTIF6`"]
255pub type CHTIF6W = CHTIF7W;
256#[doc = r" Proxy"]
257pub struct _CHTIF6W<'a> {
258    w: &'a mut W,
259}
260impl<'a> _CHTIF6W<'a> {
261    #[doc = r" Writes `variant` to the field"]
262    #[inline]
263    pub fn variant(self, variant: CHTIF6W) -> &'a mut W {
264        {
265            self.bit(variant._bits())
266        }
267    }
268    #[doc = "Clears the HTIF flag in the ISR register"]
269    #[inline]
270    pub fn clear(self) -> &'a mut W {
271        self.variant(CHTIF7W::CLEAR)
272    }
273    #[doc = r" Sets the field bit"]
274    pub fn set_bit(self) -> &'a mut W {
275        self.bit(true)
276    }
277    #[doc = r" Clears the field bit"]
278    pub fn clear_bit(self) -> &'a mut W {
279        self.bit(false)
280    }
281    #[doc = r" Writes raw bits to the field"]
282    #[inline]
283    pub fn bit(self, value: bool) -> &'a mut W {
284        const MASK: bool = true;
285        const OFFSET: u8 = 22;
286        self.w.bits &= !((MASK as u32) << OFFSET);
287        self.w.bits |= ((value & MASK) as u32) << OFFSET;
288        self.w
289    }
290}
291#[doc = "Values that can be written to the field `CTCIF6`"]
292pub type CTCIF6W = CTCIF7W;
293#[doc = r" Proxy"]
294pub struct _CTCIF6W<'a> {
295    w: &'a mut W,
296}
297impl<'a> _CTCIF6W<'a> {
298    #[doc = r" Writes `variant` to the field"]
299    #[inline]
300    pub fn variant(self, variant: CTCIF6W) -> &'a mut W {
301        {
302            self.bit(variant._bits())
303        }
304    }
305    #[doc = "Clears the TCIF flag in the ISR register"]
306    #[inline]
307    pub fn clear(self) -> &'a mut W {
308        self.variant(CTCIF7W::CLEAR)
309    }
310    #[doc = r" Sets the field bit"]
311    pub fn set_bit(self) -> &'a mut W {
312        self.bit(true)
313    }
314    #[doc = r" Clears the field bit"]
315    pub fn clear_bit(self) -> &'a mut W {
316        self.bit(false)
317    }
318    #[doc = r" Writes raw bits to the field"]
319    #[inline]
320    pub fn bit(self, value: bool) -> &'a mut W {
321        const MASK: bool = true;
322        const OFFSET: u8 = 21;
323        self.w.bits &= !((MASK as u32) << OFFSET);
324        self.w.bits |= ((value & MASK) as u32) << OFFSET;
325        self.w
326    }
327}
328#[doc = "Values that can be written to the field `CGIF6`"]
329pub type CGIF6W = CGIF7W;
330#[doc = r" Proxy"]
331pub struct _CGIF6W<'a> {
332    w: &'a mut W,
333}
334impl<'a> _CGIF6W<'a> {
335    #[doc = r" Writes `variant` to the field"]
336    #[inline]
337    pub fn variant(self, variant: CGIF6W) -> &'a mut W {
338        {
339            self.bit(variant._bits())
340        }
341    }
342    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
343    #[inline]
344    pub fn clear(self) -> &'a mut W {
345        self.variant(CGIF7W::CLEAR)
346    }
347    #[doc = r" Sets the field bit"]
348    pub fn set_bit(self) -> &'a mut W {
349        self.bit(true)
350    }
351    #[doc = r" Clears the field bit"]
352    pub fn clear_bit(self) -> &'a mut W {
353        self.bit(false)
354    }
355    #[doc = r" Writes raw bits to the field"]
356    #[inline]
357    pub fn bit(self, value: bool) -> &'a mut W {
358        const MASK: bool = true;
359        const OFFSET: u8 = 20;
360        self.w.bits &= !((MASK as u32) << OFFSET);
361        self.w.bits |= ((value & MASK) as u32) << OFFSET;
362        self.w
363    }
364}
365#[doc = "Values that can be written to the field `CTEIF5`"]
366pub type CTEIF5W = CTEIF7W;
367#[doc = r" Proxy"]
368pub struct _CTEIF5W<'a> {
369    w: &'a mut W,
370}
371impl<'a> _CTEIF5W<'a> {
372    #[doc = r" Writes `variant` to the field"]
373    #[inline]
374    pub fn variant(self, variant: CTEIF5W) -> &'a mut W {
375        {
376            self.bit(variant._bits())
377        }
378    }
379    #[doc = "Clears the TEIF flag in the ISR register"]
380    #[inline]
381    pub fn clear(self) -> &'a mut W {
382        self.variant(CTEIF7W::CLEAR)
383    }
384    #[doc = r" Sets the field bit"]
385    pub fn set_bit(self) -> &'a mut W {
386        self.bit(true)
387    }
388    #[doc = r" Clears the field bit"]
389    pub fn clear_bit(self) -> &'a mut W {
390        self.bit(false)
391    }
392    #[doc = r" Writes raw bits to the field"]
393    #[inline]
394    pub fn bit(self, value: bool) -> &'a mut W {
395        const MASK: bool = true;
396        const OFFSET: u8 = 19;
397        self.w.bits &= !((MASK as u32) << OFFSET);
398        self.w.bits |= ((value & MASK) as u32) << OFFSET;
399        self.w
400    }
401}
402#[doc = "Values that can be written to the field `CHTIF5`"]
403pub type CHTIF5W = CHTIF7W;
404#[doc = r" Proxy"]
405pub struct _CHTIF5W<'a> {
406    w: &'a mut W,
407}
408impl<'a> _CHTIF5W<'a> {
409    #[doc = r" Writes `variant` to the field"]
410    #[inline]
411    pub fn variant(self, variant: CHTIF5W) -> &'a mut W {
412        {
413            self.bit(variant._bits())
414        }
415    }
416    #[doc = "Clears the HTIF flag in the ISR register"]
417    #[inline]
418    pub fn clear(self) -> &'a mut W {
419        self.variant(CHTIF7W::CLEAR)
420    }
421    #[doc = r" Sets the field bit"]
422    pub fn set_bit(self) -> &'a mut W {
423        self.bit(true)
424    }
425    #[doc = r" Clears the field bit"]
426    pub fn clear_bit(self) -> &'a mut W {
427        self.bit(false)
428    }
429    #[doc = r" Writes raw bits to the field"]
430    #[inline]
431    pub fn bit(self, value: bool) -> &'a mut W {
432        const MASK: bool = true;
433        const OFFSET: u8 = 18;
434        self.w.bits &= !((MASK as u32) << OFFSET);
435        self.w.bits |= ((value & MASK) as u32) << OFFSET;
436        self.w
437    }
438}
439#[doc = "Values that can be written to the field `CTCIF5`"]
440pub type CTCIF5W = CTCIF7W;
441#[doc = r" Proxy"]
442pub struct _CTCIF5W<'a> {
443    w: &'a mut W,
444}
445impl<'a> _CTCIF5W<'a> {
446    #[doc = r" Writes `variant` to the field"]
447    #[inline]
448    pub fn variant(self, variant: CTCIF5W) -> &'a mut W {
449        {
450            self.bit(variant._bits())
451        }
452    }
453    #[doc = "Clears the TCIF flag in the ISR register"]
454    #[inline]
455    pub fn clear(self) -> &'a mut W {
456        self.variant(CTCIF7W::CLEAR)
457    }
458    #[doc = r" Sets the field bit"]
459    pub fn set_bit(self) -> &'a mut W {
460        self.bit(true)
461    }
462    #[doc = r" Clears the field bit"]
463    pub fn clear_bit(self) -> &'a mut W {
464        self.bit(false)
465    }
466    #[doc = r" Writes raw bits to the field"]
467    #[inline]
468    pub fn bit(self, value: bool) -> &'a mut W {
469        const MASK: bool = true;
470        const OFFSET: u8 = 17;
471        self.w.bits &= !((MASK as u32) << OFFSET);
472        self.w.bits |= ((value & MASK) as u32) << OFFSET;
473        self.w
474    }
475}
476#[doc = "Values that can be written to the field `CGIF5`"]
477pub type CGIF5W = CGIF7W;
478#[doc = r" Proxy"]
479pub struct _CGIF5W<'a> {
480    w: &'a mut W,
481}
482impl<'a> _CGIF5W<'a> {
483    #[doc = r" Writes `variant` to the field"]
484    #[inline]
485    pub fn variant(self, variant: CGIF5W) -> &'a mut W {
486        {
487            self.bit(variant._bits())
488        }
489    }
490    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
491    #[inline]
492    pub fn clear(self) -> &'a mut W {
493        self.variant(CGIF7W::CLEAR)
494    }
495    #[doc = r" Sets the field bit"]
496    pub fn set_bit(self) -> &'a mut W {
497        self.bit(true)
498    }
499    #[doc = r" Clears the field bit"]
500    pub fn clear_bit(self) -> &'a mut W {
501        self.bit(false)
502    }
503    #[doc = r" Writes raw bits to the field"]
504    #[inline]
505    pub fn bit(self, value: bool) -> &'a mut W {
506        const MASK: bool = true;
507        const OFFSET: u8 = 16;
508        self.w.bits &= !((MASK as u32) << OFFSET);
509        self.w.bits |= ((value & MASK) as u32) << OFFSET;
510        self.w
511    }
512}
513#[doc = "Values that can be written to the field `CTEIF4`"]
514pub type CTEIF4W = CTEIF7W;
515#[doc = r" Proxy"]
516pub struct _CTEIF4W<'a> {
517    w: &'a mut W,
518}
519impl<'a> _CTEIF4W<'a> {
520    #[doc = r" Writes `variant` to the field"]
521    #[inline]
522    pub fn variant(self, variant: CTEIF4W) -> &'a mut W {
523        {
524            self.bit(variant._bits())
525        }
526    }
527    #[doc = "Clears the TEIF flag in the ISR register"]
528    #[inline]
529    pub fn clear(self) -> &'a mut W {
530        self.variant(CTEIF7W::CLEAR)
531    }
532    #[doc = r" Sets the field bit"]
533    pub fn set_bit(self) -> &'a mut W {
534        self.bit(true)
535    }
536    #[doc = r" Clears the field bit"]
537    pub fn clear_bit(self) -> &'a mut W {
538        self.bit(false)
539    }
540    #[doc = r" Writes raw bits to the field"]
541    #[inline]
542    pub fn bit(self, value: bool) -> &'a mut W {
543        const MASK: bool = true;
544        const OFFSET: u8 = 15;
545        self.w.bits &= !((MASK as u32) << OFFSET);
546        self.w.bits |= ((value & MASK) as u32) << OFFSET;
547        self.w
548    }
549}
550#[doc = "Values that can be written to the field `CHTIF4`"]
551pub type CHTIF4W = CHTIF7W;
552#[doc = r" Proxy"]
553pub struct _CHTIF4W<'a> {
554    w: &'a mut W,
555}
556impl<'a> _CHTIF4W<'a> {
557    #[doc = r" Writes `variant` to the field"]
558    #[inline]
559    pub fn variant(self, variant: CHTIF4W) -> &'a mut W {
560        {
561            self.bit(variant._bits())
562        }
563    }
564    #[doc = "Clears the HTIF flag in the ISR register"]
565    #[inline]
566    pub fn clear(self) -> &'a mut W {
567        self.variant(CHTIF7W::CLEAR)
568    }
569    #[doc = r" Sets the field bit"]
570    pub fn set_bit(self) -> &'a mut W {
571        self.bit(true)
572    }
573    #[doc = r" Clears the field bit"]
574    pub fn clear_bit(self) -> &'a mut W {
575        self.bit(false)
576    }
577    #[doc = r" Writes raw bits to the field"]
578    #[inline]
579    pub fn bit(self, value: bool) -> &'a mut W {
580        const MASK: bool = true;
581        const OFFSET: u8 = 14;
582        self.w.bits &= !((MASK as u32) << OFFSET);
583        self.w.bits |= ((value & MASK) as u32) << OFFSET;
584        self.w
585    }
586}
587#[doc = "Values that can be written to the field `CTCIF4`"]
588pub type CTCIF4W = CTCIF7W;
589#[doc = r" Proxy"]
590pub struct _CTCIF4W<'a> {
591    w: &'a mut W,
592}
593impl<'a> _CTCIF4W<'a> {
594    #[doc = r" Writes `variant` to the field"]
595    #[inline]
596    pub fn variant(self, variant: CTCIF4W) -> &'a mut W {
597        {
598            self.bit(variant._bits())
599        }
600    }
601    #[doc = "Clears the TCIF flag in the ISR register"]
602    #[inline]
603    pub fn clear(self) -> &'a mut W {
604        self.variant(CTCIF7W::CLEAR)
605    }
606    #[doc = r" Sets the field bit"]
607    pub fn set_bit(self) -> &'a mut W {
608        self.bit(true)
609    }
610    #[doc = r" Clears the field bit"]
611    pub fn clear_bit(self) -> &'a mut W {
612        self.bit(false)
613    }
614    #[doc = r" Writes raw bits to the field"]
615    #[inline]
616    pub fn bit(self, value: bool) -> &'a mut W {
617        const MASK: bool = true;
618        const OFFSET: u8 = 13;
619        self.w.bits &= !((MASK as u32) << OFFSET);
620        self.w.bits |= ((value & MASK) as u32) << OFFSET;
621        self.w
622    }
623}
624#[doc = "Values that can be written to the field `CGIF4`"]
625pub type CGIF4W = CGIF7W;
626#[doc = r" Proxy"]
627pub struct _CGIF4W<'a> {
628    w: &'a mut W,
629}
630impl<'a> _CGIF4W<'a> {
631    #[doc = r" Writes `variant` to the field"]
632    #[inline]
633    pub fn variant(self, variant: CGIF4W) -> &'a mut W {
634        {
635            self.bit(variant._bits())
636        }
637    }
638    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
639    #[inline]
640    pub fn clear(self) -> &'a mut W {
641        self.variant(CGIF7W::CLEAR)
642    }
643    #[doc = r" Sets the field bit"]
644    pub fn set_bit(self) -> &'a mut W {
645        self.bit(true)
646    }
647    #[doc = r" Clears the field bit"]
648    pub fn clear_bit(self) -> &'a mut W {
649        self.bit(false)
650    }
651    #[doc = r" Writes raw bits to the field"]
652    #[inline]
653    pub fn bit(self, value: bool) -> &'a mut W {
654        const MASK: bool = true;
655        const OFFSET: u8 = 12;
656        self.w.bits &= !((MASK as u32) << OFFSET);
657        self.w.bits |= ((value & MASK) as u32) << OFFSET;
658        self.w
659    }
660}
661#[doc = "Values that can be written to the field `CTEIF3`"]
662pub type CTEIF3W = CTEIF7W;
663#[doc = r" Proxy"]
664pub struct _CTEIF3W<'a> {
665    w: &'a mut W,
666}
667impl<'a> _CTEIF3W<'a> {
668    #[doc = r" Writes `variant` to the field"]
669    #[inline]
670    pub fn variant(self, variant: CTEIF3W) -> &'a mut W {
671        {
672            self.bit(variant._bits())
673        }
674    }
675    #[doc = "Clears the TEIF flag in the ISR register"]
676    #[inline]
677    pub fn clear(self) -> &'a mut W {
678        self.variant(CTEIF7W::CLEAR)
679    }
680    #[doc = r" Sets the field bit"]
681    pub fn set_bit(self) -> &'a mut W {
682        self.bit(true)
683    }
684    #[doc = r" Clears the field bit"]
685    pub fn clear_bit(self) -> &'a mut W {
686        self.bit(false)
687    }
688    #[doc = r" Writes raw bits to the field"]
689    #[inline]
690    pub fn bit(self, value: bool) -> &'a mut W {
691        const MASK: bool = true;
692        const OFFSET: u8 = 11;
693        self.w.bits &= !((MASK as u32) << OFFSET);
694        self.w.bits |= ((value & MASK) as u32) << OFFSET;
695        self.w
696    }
697}
698#[doc = "Values that can be written to the field `CHTIF3`"]
699pub type CHTIF3W = CHTIF7W;
700#[doc = r" Proxy"]
701pub struct _CHTIF3W<'a> {
702    w: &'a mut W,
703}
704impl<'a> _CHTIF3W<'a> {
705    #[doc = r" Writes `variant` to the field"]
706    #[inline]
707    pub fn variant(self, variant: CHTIF3W) -> &'a mut W {
708        {
709            self.bit(variant._bits())
710        }
711    }
712    #[doc = "Clears the HTIF flag in the ISR register"]
713    #[inline]
714    pub fn clear(self) -> &'a mut W {
715        self.variant(CHTIF7W::CLEAR)
716    }
717    #[doc = r" Sets the field bit"]
718    pub fn set_bit(self) -> &'a mut W {
719        self.bit(true)
720    }
721    #[doc = r" Clears the field bit"]
722    pub fn clear_bit(self) -> &'a mut W {
723        self.bit(false)
724    }
725    #[doc = r" Writes raw bits to the field"]
726    #[inline]
727    pub fn bit(self, value: bool) -> &'a mut W {
728        const MASK: bool = true;
729        const OFFSET: u8 = 10;
730        self.w.bits &= !((MASK as u32) << OFFSET);
731        self.w.bits |= ((value & MASK) as u32) << OFFSET;
732        self.w
733    }
734}
735#[doc = "Values that can be written to the field `CTCIF3`"]
736pub type CTCIF3W = CTCIF7W;
737#[doc = r" Proxy"]
738pub struct _CTCIF3W<'a> {
739    w: &'a mut W,
740}
741impl<'a> _CTCIF3W<'a> {
742    #[doc = r" Writes `variant` to the field"]
743    #[inline]
744    pub fn variant(self, variant: CTCIF3W) -> &'a mut W {
745        {
746            self.bit(variant._bits())
747        }
748    }
749    #[doc = "Clears the TCIF flag in the ISR register"]
750    #[inline]
751    pub fn clear(self) -> &'a mut W {
752        self.variant(CTCIF7W::CLEAR)
753    }
754    #[doc = r" Sets the field bit"]
755    pub fn set_bit(self) -> &'a mut W {
756        self.bit(true)
757    }
758    #[doc = r" Clears the field bit"]
759    pub fn clear_bit(self) -> &'a mut W {
760        self.bit(false)
761    }
762    #[doc = r" Writes raw bits to the field"]
763    #[inline]
764    pub fn bit(self, value: bool) -> &'a mut W {
765        const MASK: bool = true;
766        const OFFSET: u8 = 9;
767        self.w.bits &= !((MASK as u32) << OFFSET);
768        self.w.bits |= ((value & MASK) as u32) << OFFSET;
769        self.w
770    }
771}
772#[doc = "Values that can be written to the field `CGIF3`"]
773pub type CGIF3W = CGIF7W;
774#[doc = r" Proxy"]
775pub struct _CGIF3W<'a> {
776    w: &'a mut W,
777}
778impl<'a> _CGIF3W<'a> {
779    #[doc = r" Writes `variant` to the field"]
780    #[inline]
781    pub fn variant(self, variant: CGIF3W) -> &'a mut W {
782        {
783            self.bit(variant._bits())
784        }
785    }
786    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
787    #[inline]
788    pub fn clear(self) -> &'a mut W {
789        self.variant(CGIF7W::CLEAR)
790    }
791    #[doc = r" Sets the field bit"]
792    pub fn set_bit(self) -> &'a mut W {
793        self.bit(true)
794    }
795    #[doc = r" Clears the field bit"]
796    pub fn clear_bit(self) -> &'a mut W {
797        self.bit(false)
798    }
799    #[doc = r" Writes raw bits to the field"]
800    #[inline]
801    pub fn bit(self, value: bool) -> &'a mut W {
802        const MASK: bool = true;
803        const OFFSET: u8 = 8;
804        self.w.bits &= !((MASK as u32) << OFFSET);
805        self.w.bits |= ((value & MASK) as u32) << OFFSET;
806        self.w
807    }
808}
809#[doc = "Values that can be written to the field `CTEIF2`"]
810pub type CTEIF2W = CTEIF7W;
811#[doc = r" Proxy"]
812pub struct _CTEIF2W<'a> {
813    w: &'a mut W,
814}
815impl<'a> _CTEIF2W<'a> {
816    #[doc = r" Writes `variant` to the field"]
817    #[inline]
818    pub fn variant(self, variant: CTEIF2W) -> &'a mut W {
819        {
820            self.bit(variant._bits())
821        }
822    }
823    #[doc = "Clears the TEIF flag in the ISR register"]
824    #[inline]
825    pub fn clear(self) -> &'a mut W {
826        self.variant(CTEIF7W::CLEAR)
827    }
828    #[doc = r" Sets the field bit"]
829    pub fn set_bit(self) -> &'a mut W {
830        self.bit(true)
831    }
832    #[doc = r" Clears the field bit"]
833    pub fn clear_bit(self) -> &'a mut W {
834        self.bit(false)
835    }
836    #[doc = r" Writes raw bits to the field"]
837    #[inline]
838    pub fn bit(self, value: bool) -> &'a mut W {
839        const MASK: bool = true;
840        const OFFSET: u8 = 7;
841        self.w.bits &= !((MASK as u32) << OFFSET);
842        self.w.bits |= ((value & MASK) as u32) << OFFSET;
843        self.w
844    }
845}
846#[doc = "Values that can be written to the field `CHTIF2`"]
847pub type CHTIF2W = CHTIF7W;
848#[doc = r" Proxy"]
849pub struct _CHTIF2W<'a> {
850    w: &'a mut W,
851}
852impl<'a> _CHTIF2W<'a> {
853    #[doc = r" Writes `variant` to the field"]
854    #[inline]
855    pub fn variant(self, variant: CHTIF2W) -> &'a mut W {
856        {
857            self.bit(variant._bits())
858        }
859    }
860    #[doc = "Clears the HTIF flag in the ISR register"]
861    #[inline]
862    pub fn clear(self) -> &'a mut W {
863        self.variant(CHTIF7W::CLEAR)
864    }
865    #[doc = r" Sets the field bit"]
866    pub fn set_bit(self) -> &'a mut W {
867        self.bit(true)
868    }
869    #[doc = r" Clears the field bit"]
870    pub fn clear_bit(self) -> &'a mut W {
871        self.bit(false)
872    }
873    #[doc = r" Writes raw bits to the field"]
874    #[inline]
875    pub fn bit(self, value: bool) -> &'a mut W {
876        const MASK: bool = true;
877        const OFFSET: u8 = 6;
878        self.w.bits &= !((MASK as u32) << OFFSET);
879        self.w.bits |= ((value & MASK) as u32) << OFFSET;
880        self.w
881    }
882}
883#[doc = "Values that can be written to the field `CTCIF2`"]
884pub type CTCIF2W = CTCIF7W;
885#[doc = r" Proxy"]
886pub struct _CTCIF2W<'a> {
887    w: &'a mut W,
888}
889impl<'a> _CTCIF2W<'a> {
890    #[doc = r" Writes `variant` to the field"]
891    #[inline]
892    pub fn variant(self, variant: CTCIF2W) -> &'a mut W {
893        {
894            self.bit(variant._bits())
895        }
896    }
897    #[doc = "Clears the TCIF flag in the ISR register"]
898    #[inline]
899    pub fn clear(self) -> &'a mut W {
900        self.variant(CTCIF7W::CLEAR)
901    }
902    #[doc = r" Sets the field bit"]
903    pub fn set_bit(self) -> &'a mut W {
904        self.bit(true)
905    }
906    #[doc = r" Clears the field bit"]
907    pub fn clear_bit(self) -> &'a mut W {
908        self.bit(false)
909    }
910    #[doc = r" Writes raw bits to the field"]
911    #[inline]
912    pub fn bit(self, value: bool) -> &'a mut W {
913        const MASK: bool = true;
914        const OFFSET: u8 = 5;
915        self.w.bits &= !((MASK as u32) << OFFSET);
916        self.w.bits |= ((value & MASK) as u32) << OFFSET;
917        self.w
918    }
919}
920#[doc = "Values that can be written to the field `CGIF2`"]
921pub type CGIF2W = CGIF7W;
922#[doc = r" Proxy"]
923pub struct _CGIF2W<'a> {
924    w: &'a mut W,
925}
926impl<'a> _CGIF2W<'a> {
927    #[doc = r" Writes `variant` to the field"]
928    #[inline]
929    pub fn variant(self, variant: CGIF2W) -> &'a mut W {
930        {
931            self.bit(variant._bits())
932        }
933    }
934    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
935    #[inline]
936    pub fn clear(self) -> &'a mut W {
937        self.variant(CGIF7W::CLEAR)
938    }
939    #[doc = r" Sets the field bit"]
940    pub fn set_bit(self) -> &'a mut W {
941        self.bit(true)
942    }
943    #[doc = r" Clears the field bit"]
944    pub fn clear_bit(self) -> &'a mut W {
945        self.bit(false)
946    }
947    #[doc = r" Writes raw bits to the field"]
948    #[inline]
949    pub fn bit(self, value: bool) -> &'a mut W {
950        const MASK: bool = true;
951        const OFFSET: u8 = 4;
952        self.w.bits &= !((MASK as u32) << OFFSET);
953        self.w.bits |= ((value & MASK) as u32) << OFFSET;
954        self.w
955    }
956}
957#[doc = "Values that can be written to the field `CTEIF1`"]
958pub type CTEIF1W = CTEIF7W;
959#[doc = r" Proxy"]
960pub struct _CTEIF1W<'a> {
961    w: &'a mut W,
962}
963impl<'a> _CTEIF1W<'a> {
964    #[doc = r" Writes `variant` to the field"]
965    #[inline]
966    pub fn variant(self, variant: CTEIF1W) -> &'a mut W {
967        {
968            self.bit(variant._bits())
969        }
970    }
971    #[doc = "Clears the TEIF flag in the ISR register"]
972    #[inline]
973    pub fn clear(self) -> &'a mut W {
974        self.variant(CTEIF7W::CLEAR)
975    }
976    #[doc = r" Sets the field bit"]
977    pub fn set_bit(self) -> &'a mut W {
978        self.bit(true)
979    }
980    #[doc = r" Clears the field bit"]
981    pub fn clear_bit(self) -> &'a mut W {
982        self.bit(false)
983    }
984    #[doc = r" Writes raw bits to the field"]
985    #[inline]
986    pub fn bit(self, value: bool) -> &'a mut W {
987        const MASK: bool = true;
988        const OFFSET: u8 = 3;
989        self.w.bits &= !((MASK as u32) << OFFSET);
990        self.w.bits |= ((value & MASK) as u32) << OFFSET;
991        self.w
992    }
993}
994#[doc = "Values that can be written to the field `CHTIF1`"]
995pub type CHTIF1W = CHTIF7W;
996#[doc = r" Proxy"]
997pub struct _CHTIF1W<'a> {
998    w: &'a mut W,
999}
1000impl<'a> _CHTIF1W<'a> {
1001    #[doc = r" Writes `variant` to the field"]
1002    #[inline]
1003    pub fn variant(self, variant: CHTIF1W) -> &'a mut W {
1004        {
1005            self.bit(variant._bits())
1006        }
1007    }
1008    #[doc = "Clears the HTIF flag in the ISR register"]
1009    #[inline]
1010    pub fn clear(self) -> &'a mut W {
1011        self.variant(CHTIF7W::CLEAR)
1012    }
1013    #[doc = r" Sets the field bit"]
1014    pub fn set_bit(self) -> &'a mut W {
1015        self.bit(true)
1016    }
1017    #[doc = r" Clears the field bit"]
1018    pub fn clear_bit(self) -> &'a mut W {
1019        self.bit(false)
1020    }
1021    #[doc = r" Writes raw bits to the field"]
1022    #[inline]
1023    pub fn bit(self, value: bool) -> &'a mut W {
1024        const MASK: bool = true;
1025        const OFFSET: u8 = 2;
1026        self.w.bits &= !((MASK as u32) << OFFSET);
1027        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1028        self.w
1029    }
1030}
1031#[doc = "Values that can be written to the field `CTCIF1`"]
1032pub type CTCIF1W = CTCIF7W;
1033#[doc = r" Proxy"]
1034pub struct _CTCIF1W<'a> {
1035    w: &'a mut W,
1036}
1037impl<'a> _CTCIF1W<'a> {
1038    #[doc = r" Writes `variant` to the field"]
1039    #[inline]
1040    pub fn variant(self, variant: CTCIF1W) -> &'a mut W {
1041        {
1042            self.bit(variant._bits())
1043        }
1044    }
1045    #[doc = "Clears the TCIF flag in the ISR register"]
1046    #[inline]
1047    pub fn clear(self) -> &'a mut W {
1048        self.variant(CTCIF7W::CLEAR)
1049    }
1050    #[doc = r" Sets the field bit"]
1051    pub fn set_bit(self) -> &'a mut W {
1052        self.bit(true)
1053    }
1054    #[doc = r" Clears the field bit"]
1055    pub fn clear_bit(self) -> &'a mut W {
1056        self.bit(false)
1057    }
1058    #[doc = r" Writes raw bits to the field"]
1059    #[inline]
1060    pub fn bit(self, value: bool) -> &'a mut W {
1061        const MASK: bool = true;
1062        const OFFSET: u8 = 1;
1063        self.w.bits &= !((MASK as u32) << OFFSET);
1064        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1065        self.w
1066    }
1067}
1068#[doc = "Values that can be written to the field `CGIF1`"]
1069pub type CGIF1W = CGIF7W;
1070#[doc = r" Proxy"]
1071pub struct _CGIF1W<'a> {
1072    w: &'a mut W,
1073}
1074impl<'a> _CGIF1W<'a> {
1075    #[doc = r" Writes `variant` to the field"]
1076    #[inline]
1077    pub fn variant(self, variant: CGIF1W) -> &'a mut W {
1078        {
1079            self.bit(variant._bits())
1080        }
1081    }
1082    #[doc = "Clears the GIF, TEIF, HTIF, TCIF flags in the ISR register"]
1083    #[inline]
1084    pub fn clear(self) -> &'a mut W {
1085        self.variant(CGIF7W::CLEAR)
1086    }
1087    #[doc = r" Sets the field bit"]
1088    pub fn set_bit(self) -> &'a mut W {
1089        self.bit(true)
1090    }
1091    #[doc = r" Clears the field bit"]
1092    pub fn clear_bit(self) -> &'a mut W {
1093        self.bit(false)
1094    }
1095    #[doc = r" Writes raw bits to the field"]
1096    #[inline]
1097    pub fn bit(self, value: bool) -> &'a mut W {
1098        const MASK: bool = true;
1099        const OFFSET: u8 = 0;
1100        self.w.bits &= !((MASK as u32) << OFFSET);
1101        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1102        self.w
1103    }
1104}
1105impl W {
1106    #[doc = r" Reset value of the register"]
1107    #[inline]
1108    pub fn reset_value() -> W {
1109        W { bits: 0 }
1110    }
1111    #[doc = r" Writes raw bits to the register"]
1112    #[inline]
1113    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1114        self.bits = bits;
1115        self
1116    }
1117    #[doc = "Bit 27 - Channel x transfer error clear (x = 1 ..7)"]
1118    #[inline]
1119    pub fn cteif7(&mut self) -> _CTEIF7W {
1120        _CTEIF7W { w: self }
1121    }
1122    #[doc = "Bit 26 - Channel x half transfer clear (x = 1 ..7)"]
1123    #[inline]
1124    pub fn chtif7(&mut self) -> _CHTIF7W {
1125        _CHTIF7W { w: self }
1126    }
1127    #[doc = "Bit 25 - Channel x transfer complete clear (x = 1 ..7)"]
1128    #[inline]
1129    pub fn ctcif7(&mut self) -> _CTCIF7W {
1130        _CTCIF7W { w: self }
1131    }
1132    #[doc = "Bit 24 - Channel x global interrupt clear (x = 1 ..7)"]
1133    #[inline]
1134    pub fn cgif7(&mut self) -> _CGIF7W {
1135        _CGIF7W { w: self }
1136    }
1137    #[doc = "Bit 23 - Channel x transfer error clear (x = 1 ..7)"]
1138    #[inline]
1139    pub fn cteif6(&mut self) -> _CTEIF6W {
1140        _CTEIF6W { w: self }
1141    }
1142    #[doc = "Bit 22 - Channel x half transfer clear (x = 1 ..7)"]
1143    #[inline]
1144    pub fn chtif6(&mut self) -> _CHTIF6W {
1145        _CHTIF6W { w: self }
1146    }
1147    #[doc = "Bit 21 - Channel x transfer complete clear (x = 1 ..7)"]
1148    #[inline]
1149    pub fn ctcif6(&mut self) -> _CTCIF6W {
1150        _CTCIF6W { w: self }
1151    }
1152    #[doc = "Bit 20 - Channel x global interrupt clear (x = 1 ..7)"]
1153    #[inline]
1154    pub fn cgif6(&mut self) -> _CGIF6W {
1155        _CGIF6W { w: self }
1156    }
1157    #[doc = "Bit 19 - Channel x transfer error clear (x = 1 ..7)"]
1158    #[inline]
1159    pub fn cteif5(&mut self) -> _CTEIF5W {
1160        _CTEIF5W { w: self }
1161    }
1162    #[doc = "Bit 18 - Channel x half transfer clear (x = 1 ..7)"]
1163    #[inline]
1164    pub fn chtif5(&mut self) -> _CHTIF5W {
1165        _CHTIF5W { w: self }
1166    }
1167    #[doc = "Bit 17 - Channel x transfer complete clear (x = 1 ..7)"]
1168    #[inline]
1169    pub fn ctcif5(&mut self) -> _CTCIF5W {
1170        _CTCIF5W { w: self }
1171    }
1172    #[doc = "Bit 16 - Channel x global interrupt clear (x = 1 ..7)"]
1173    #[inline]
1174    pub fn cgif5(&mut self) -> _CGIF5W {
1175        _CGIF5W { w: self }
1176    }
1177    #[doc = "Bit 15 - Channel x transfer error clear (x = 1 ..7)"]
1178    #[inline]
1179    pub fn cteif4(&mut self) -> _CTEIF4W {
1180        _CTEIF4W { w: self }
1181    }
1182    #[doc = "Bit 14 - Channel x half transfer clear (x = 1 ..7)"]
1183    #[inline]
1184    pub fn chtif4(&mut self) -> _CHTIF4W {
1185        _CHTIF4W { w: self }
1186    }
1187    #[doc = "Bit 13 - Channel x transfer complete clear (x = 1 ..7)"]
1188    #[inline]
1189    pub fn ctcif4(&mut self) -> _CTCIF4W {
1190        _CTCIF4W { w: self }
1191    }
1192    #[doc = "Bit 12 - Channel x global interrupt clear (x = 1 ..7)"]
1193    #[inline]
1194    pub fn cgif4(&mut self) -> _CGIF4W {
1195        _CGIF4W { w: self }
1196    }
1197    #[doc = "Bit 11 - Channel x transfer error clear (x = 1 ..7)"]
1198    #[inline]
1199    pub fn cteif3(&mut self) -> _CTEIF3W {
1200        _CTEIF3W { w: self }
1201    }
1202    #[doc = "Bit 10 - Channel x half transfer clear (x = 1 ..7)"]
1203    #[inline]
1204    pub fn chtif3(&mut self) -> _CHTIF3W {
1205        _CHTIF3W { w: self }
1206    }
1207    #[doc = "Bit 9 - Channel x transfer complete clear (x = 1 ..7)"]
1208    #[inline]
1209    pub fn ctcif3(&mut self) -> _CTCIF3W {
1210        _CTCIF3W { w: self }
1211    }
1212    #[doc = "Bit 8 - Channel x global interrupt clear (x = 1 ..7)"]
1213    #[inline]
1214    pub fn cgif3(&mut self) -> _CGIF3W {
1215        _CGIF3W { w: self }
1216    }
1217    #[doc = "Bit 7 - Channel x transfer error clear (x = 1 ..7)"]
1218    #[inline]
1219    pub fn cteif2(&mut self) -> _CTEIF2W {
1220        _CTEIF2W { w: self }
1221    }
1222    #[doc = "Bit 6 - Channel x half transfer clear (x = 1 ..7)"]
1223    #[inline]
1224    pub fn chtif2(&mut self) -> _CHTIF2W {
1225        _CHTIF2W { w: self }
1226    }
1227    #[doc = "Bit 5 - Channel x transfer complete clear (x = 1 ..7)"]
1228    #[inline]
1229    pub fn ctcif2(&mut self) -> _CTCIF2W {
1230        _CTCIF2W { w: self }
1231    }
1232    #[doc = "Bit 4 - Channel x global interrupt clear (x = 1 ..7)"]
1233    #[inline]
1234    pub fn cgif2(&mut self) -> _CGIF2W {
1235        _CGIF2W { w: self }
1236    }
1237    #[doc = "Bit 3 - Channel x transfer error clear (x = 1 ..7)"]
1238    #[inline]
1239    pub fn cteif1(&mut self) -> _CTEIF1W {
1240        _CTEIF1W { w: self }
1241    }
1242    #[doc = "Bit 2 - Channel x half transfer clear (x = 1 ..7)"]
1243    #[inline]
1244    pub fn chtif1(&mut self) -> _CHTIF1W {
1245        _CHTIF1W { w: self }
1246    }
1247    #[doc = "Bit 1 - Channel x transfer complete clear (x = 1 ..7)"]
1248    #[inline]
1249    pub fn ctcif1(&mut self) -> _CTCIF1W {
1250        _CTCIF1W { w: self }
1251    }
1252    #[doc = "Bit 0 - Channel x global interrupt clear (x = 1 ..7)"]
1253    #[inline]
1254    pub fn cgif1(&mut self) -> _CGIF1W {
1255        _CGIF1W { w: self }
1256    }
1257}
stm32l4x2_pac/dma1/ifcr.rs

stm32l4x2_pac/dma1/
ifcr.rs
