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::LIFCR {
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 CTCIF3R {
47 bits: bool,
48}
49impl CTCIF3R {
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 CHTIF3R {
68 bits: bool,
69}
70impl CHTIF3R {
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 CTEIF3R {
89 bits: bool,
90}
91impl CTEIF3R {
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 CDMEIF3R {
110 bits: bool,
111}
112impl CDMEIF3R {
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 CFEIF3R {
131 bits: bool,
132}
133impl CFEIF3R {
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 CTCIF2R {
152 bits: bool,
153}
154impl CTCIF2R {
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 CHTIF2R {
173 bits: bool,
174}
175impl CHTIF2R {
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 CTEIF2R {
194 bits: bool,
195}
196impl CTEIF2R {
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 CDMEIF2R {
215 bits: bool,
216}
217impl CDMEIF2R {
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 CFEIF2R {
236 bits: bool,
237}
238impl CFEIF2R {
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 CTCIF1R {
257 bits: bool,
258}
259impl CTCIF1R {
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 CHTIF1R {
278 bits: bool,
279}
280impl CHTIF1R {
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 CTEIF1R {
299 bits: bool,
300}
301impl CTEIF1R {
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 CDMEIF1R {
320 bits: bool,
321}
322impl CDMEIF1R {
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 CFEIF1R {
341 bits: bool,
342}
343impl CFEIF1R {
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 CTCIF0R {
362 bits: bool,
363}
364impl CTCIF0R {
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 CHTIF0R {
383 bits: bool,
384}
385impl CHTIF0R {
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 CTEIF0R {
404 bits: bool,
405}
406impl CTEIF0R {
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 CDMEIF0R {
425 bits: bool,
426}
427impl CDMEIF0R {
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 CFEIF0R {
446 bits: bool,
447}
448impl CFEIF0R {
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" Proxy"]
466pub struct _CTCIF3W<'a> {
467 w: &'a mut W,
468}
469impl<'a> _CTCIF3W<'a> {
470 #[doc = r" Sets the field bit"]
471 pub fn set_bit(self) -> &'a mut W {
472 self.bit(true)
473 }
474 #[doc = r" Clears the field bit"]
475 pub fn clear_bit(self) -> &'a mut W {
476 self.bit(false)
477 }
478 #[doc = r" Writes raw bits to the field"]
479 #[inline]
480 pub fn bit(self, value: bool) -> &'a mut W {
481 const MASK: bool = true;
482 const OFFSET: u8 = 27;
483 self.w.bits &= !((MASK as u32) << OFFSET);
484 self.w.bits |= ((value & MASK) as u32) << OFFSET;
485 self.w
486 }
487}
488#[doc = r" Proxy"]
489pub struct _CHTIF3W<'a> {
490 w: &'a mut W,
491}
492impl<'a> _CHTIF3W<'a> {
493 #[doc = r" Sets the field bit"]
494 pub fn set_bit(self) -> &'a mut W {
495 self.bit(true)
496 }
497 #[doc = r" Clears the field bit"]
498 pub fn clear_bit(self) -> &'a mut W {
499 self.bit(false)
500 }
501 #[doc = r" Writes raw bits to the field"]
502 #[inline]
503 pub fn bit(self, value: bool) -> &'a mut W {
504 const MASK: bool = true;
505 const OFFSET: u8 = 26;
506 self.w.bits &= !((MASK as u32) << OFFSET);
507 self.w.bits |= ((value & MASK) as u32) << OFFSET;
508 self.w
509 }
510}
511#[doc = r" Proxy"]
512pub struct _CTEIF3W<'a> {
513 w: &'a mut W,
514}
515impl<'a> _CTEIF3W<'a> {
516 #[doc = r" Sets the field bit"]
517 pub fn set_bit(self) -> &'a mut W {
518 self.bit(true)
519 }
520 #[doc = r" Clears the field bit"]
521 pub fn clear_bit(self) -> &'a mut W {
522 self.bit(false)
523 }
524 #[doc = r" Writes raw bits to the field"]
525 #[inline]
526 pub fn bit(self, value: bool) -> &'a mut W {
527 const MASK: bool = true;
528 const OFFSET: u8 = 25;
529 self.w.bits &= !((MASK as u32) << OFFSET);
530 self.w.bits |= ((value & MASK) as u32) << OFFSET;
531 self.w
532 }
533}
534#[doc = r" Proxy"]
535pub struct _CDMEIF3W<'a> {
536 w: &'a mut W,
537}
538impl<'a> _CDMEIF3W<'a> {
539 #[doc = r" Sets the field bit"]
540 pub fn set_bit(self) -> &'a mut W {
541 self.bit(true)
542 }
543 #[doc = r" Clears the field bit"]
544 pub fn clear_bit(self) -> &'a mut W {
545 self.bit(false)
546 }
547 #[doc = r" Writes raw bits to the field"]
548 #[inline]
549 pub fn bit(self, value: bool) -> &'a mut W {
550 const MASK: bool = true;
551 const OFFSET: u8 = 24;
552 self.w.bits &= !((MASK as u32) << OFFSET);
553 self.w.bits |= ((value & MASK) as u32) << OFFSET;
554 self.w
555 }
556}
557#[doc = r" Proxy"]
558pub struct _CFEIF3W<'a> {
559 w: &'a mut W,
560}
561impl<'a> _CFEIF3W<'a> {
562 #[doc = r" Sets the field bit"]
563 pub fn set_bit(self) -> &'a mut W {
564 self.bit(true)
565 }
566 #[doc = r" Clears the field bit"]
567 pub fn clear_bit(self) -> &'a mut W {
568 self.bit(false)
569 }
570 #[doc = r" Writes raw bits to the field"]
571 #[inline]
572 pub fn bit(self, value: bool) -> &'a mut W {
573 const MASK: bool = true;
574 const OFFSET: u8 = 22;
575 self.w.bits &= !((MASK as u32) << OFFSET);
576 self.w.bits |= ((value & MASK) as u32) << OFFSET;
577 self.w
578 }
579}
580#[doc = r" Proxy"]
581pub struct _CTCIF2W<'a> {
582 w: &'a mut W,
583}
584impl<'a> _CTCIF2W<'a> {
585 #[doc = r" Sets the field bit"]
586 pub fn set_bit(self) -> &'a mut W {
587 self.bit(true)
588 }
589 #[doc = r" Clears the field bit"]
590 pub fn clear_bit(self) -> &'a mut W {
591 self.bit(false)
592 }
593 #[doc = r" Writes raw bits to the field"]
594 #[inline]
595 pub fn bit(self, value: bool) -> &'a mut W {
596 const MASK: bool = true;
597 const OFFSET: u8 = 21;
598 self.w.bits &= !((MASK as u32) << OFFSET);
599 self.w.bits |= ((value & MASK) as u32) << OFFSET;
600 self.w
601 }
602}
603#[doc = r" Proxy"]
604pub struct _CHTIF2W<'a> {
605 w: &'a mut W,
606}
607impl<'a> _CHTIF2W<'a> {
608 #[doc = r" Sets the field bit"]
609 pub fn set_bit(self) -> &'a mut W {
610 self.bit(true)
611 }
612 #[doc = r" Clears the field bit"]
613 pub fn clear_bit(self) -> &'a mut W {
614 self.bit(false)
615 }
616 #[doc = r" Writes raw bits to the field"]
617 #[inline]
618 pub fn bit(self, value: bool) -> &'a mut W {
619 const MASK: bool = true;
620 const OFFSET: u8 = 20;
621 self.w.bits &= !((MASK as u32) << OFFSET);
622 self.w.bits |= ((value & MASK) as u32) << OFFSET;
623 self.w
624 }
625}
626#[doc = r" Proxy"]
627pub struct _CTEIF2W<'a> {
628 w: &'a mut W,
629}
630impl<'a> _CTEIF2W<'a> {
631 #[doc = r" Sets the field bit"]
632 pub fn set_bit(self) -> &'a mut W {
633 self.bit(true)
634 }
635 #[doc = r" Clears the field bit"]
636 pub fn clear_bit(self) -> &'a mut W {
637 self.bit(false)
638 }
639 #[doc = r" Writes raw bits to the field"]
640 #[inline]
641 pub fn bit(self, value: bool) -> &'a mut W {
642 const MASK: bool = true;
643 const OFFSET: u8 = 19;
644 self.w.bits &= !((MASK as u32) << OFFSET);
645 self.w.bits |= ((value & MASK) as u32) << OFFSET;
646 self.w
647 }
648}
649#[doc = r" Proxy"]
650pub struct _CDMEIF2W<'a> {
651 w: &'a mut W,
652}
653impl<'a> _CDMEIF2W<'a> {
654 #[doc = r" Sets the field bit"]
655 pub fn set_bit(self) -> &'a mut W {
656 self.bit(true)
657 }
658 #[doc = r" Clears the field bit"]
659 pub fn clear_bit(self) -> &'a mut W {
660 self.bit(false)
661 }
662 #[doc = r" Writes raw bits to the field"]
663 #[inline]
664 pub fn bit(self, value: bool) -> &'a mut W {
665 const MASK: bool = true;
666 const OFFSET: u8 = 18;
667 self.w.bits &= !((MASK as u32) << OFFSET);
668 self.w.bits |= ((value & MASK) as u32) << OFFSET;
669 self.w
670 }
671}
672#[doc = r" Proxy"]
673pub struct _CFEIF2W<'a> {
674 w: &'a mut W,
675}
676impl<'a> _CFEIF2W<'a> {
677 #[doc = r" Sets the field bit"]
678 pub fn set_bit(self) -> &'a mut W {
679 self.bit(true)
680 }
681 #[doc = r" Clears the field bit"]
682 pub fn clear_bit(self) -> &'a mut W {
683 self.bit(false)
684 }
685 #[doc = r" Writes raw bits to the field"]
686 #[inline]
687 pub fn bit(self, value: bool) -> &'a mut W {
688 const MASK: bool = true;
689 const OFFSET: u8 = 16;
690 self.w.bits &= !((MASK as u32) << OFFSET);
691 self.w.bits |= ((value & MASK) as u32) << OFFSET;
692 self.w
693 }
694}
695#[doc = r" Proxy"]
696pub struct _CTCIF1W<'a> {
697 w: &'a mut W,
698}
699impl<'a> _CTCIF1W<'a> {
700 #[doc = r" Sets the field bit"]
701 pub fn set_bit(self) -> &'a mut W {
702 self.bit(true)
703 }
704 #[doc = r" Clears the field bit"]
705 pub fn clear_bit(self) -> &'a mut W {
706 self.bit(false)
707 }
708 #[doc = r" Writes raw bits to the field"]
709 #[inline]
710 pub fn bit(self, value: bool) -> &'a mut W {
711 const MASK: bool = true;
712 const OFFSET: u8 = 11;
713 self.w.bits &= !((MASK as u32) << OFFSET);
714 self.w.bits |= ((value & MASK) as u32) << OFFSET;
715 self.w
716 }
717}
718#[doc = r" Proxy"]
719pub struct _CHTIF1W<'a> {
720 w: &'a mut W,
721}
722impl<'a> _CHTIF1W<'a> {
723 #[doc = r" Sets the field bit"]
724 pub fn set_bit(self) -> &'a mut W {
725 self.bit(true)
726 }
727 #[doc = r" Clears the field bit"]
728 pub fn clear_bit(self) -> &'a mut W {
729 self.bit(false)
730 }
731 #[doc = r" Writes raw bits to the field"]
732 #[inline]
733 pub fn bit(self, value: bool) -> &'a mut W {
734 const MASK: bool = true;
735 const OFFSET: u8 = 10;
736 self.w.bits &= !((MASK as u32) << OFFSET);
737 self.w.bits |= ((value & MASK) as u32) << OFFSET;
738 self.w
739 }
740}
741#[doc = r" Proxy"]
742pub struct _CTEIF1W<'a> {
743 w: &'a mut W,
744}
745impl<'a> _CTEIF1W<'a> {
746 #[doc = r" Sets the field bit"]
747 pub fn set_bit(self) -> &'a mut W {
748 self.bit(true)
749 }
750 #[doc = r" Clears the field bit"]
751 pub fn clear_bit(self) -> &'a mut W {
752 self.bit(false)
753 }
754 #[doc = r" Writes raw bits to the field"]
755 #[inline]
756 pub fn bit(self, value: bool) -> &'a mut W {
757 const MASK: bool = true;
758 const OFFSET: u8 = 9;
759 self.w.bits &= !((MASK as u32) << OFFSET);
760 self.w.bits |= ((value & MASK) as u32) << OFFSET;
761 self.w
762 }
763}
764#[doc = r" Proxy"]
765pub struct _CDMEIF1W<'a> {
766 w: &'a mut W,
767}
768impl<'a> _CDMEIF1W<'a> {
769 #[doc = r" Sets the field bit"]
770 pub fn set_bit(self) -> &'a mut W {
771 self.bit(true)
772 }
773 #[doc = r" Clears the field bit"]
774 pub fn clear_bit(self) -> &'a mut W {
775 self.bit(false)
776 }
777 #[doc = r" Writes raw bits to the field"]
778 #[inline]
779 pub fn bit(self, value: bool) -> &'a mut W {
780 const MASK: bool = true;
781 const OFFSET: u8 = 8;
782 self.w.bits &= !((MASK as u32) << OFFSET);
783 self.w.bits |= ((value & MASK) as u32) << OFFSET;
784 self.w
785 }
786}
787#[doc = r" Proxy"]
788pub struct _CFEIF1W<'a> {
789 w: &'a mut W,
790}
791impl<'a> _CFEIF1W<'a> {
792 #[doc = r" Sets the field bit"]
793 pub fn set_bit(self) -> &'a mut W {
794 self.bit(true)
795 }
796 #[doc = r" Clears the field bit"]
797 pub fn clear_bit(self) -> &'a mut W {
798 self.bit(false)
799 }
800 #[doc = r" Writes raw bits to the field"]
801 #[inline]
802 pub fn bit(self, value: bool) -> &'a mut W {
803 const MASK: bool = true;
804 const OFFSET: u8 = 6;
805 self.w.bits &= !((MASK as u32) << OFFSET);
806 self.w.bits |= ((value & MASK) as u32) << OFFSET;
807 self.w
808 }
809}
810#[doc = r" Proxy"]
811pub struct _CTCIF0W<'a> {
812 w: &'a mut W,
813}
814impl<'a> _CTCIF0W<'a> {
815 #[doc = r" Sets the field bit"]
816 pub fn set_bit(self) -> &'a mut W {
817 self.bit(true)
818 }
819 #[doc = r" Clears the field bit"]
820 pub fn clear_bit(self) -> &'a mut W {
821 self.bit(false)
822 }
823 #[doc = r" Writes raw bits to the field"]
824 #[inline]
825 pub fn bit(self, value: bool) -> &'a mut W {
826 const MASK: bool = true;
827 const OFFSET: u8 = 5;
828 self.w.bits &= !((MASK as u32) << OFFSET);
829 self.w.bits |= ((value & MASK) as u32) << OFFSET;
830 self.w
831 }
832}
833#[doc = r" Proxy"]
834pub struct _CHTIF0W<'a> {
835 w: &'a mut W,
836}
837impl<'a> _CHTIF0W<'a> {
838 #[doc = r" Sets the field bit"]
839 pub fn set_bit(self) -> &'a mut W {
840 self.bit(true)
841 }
842 #[doc = r" Clears the field bit"]
843 pub fn clear_bit(self) -> &'a mut W {
844 self.bit(false)
845 }
846 #[doc = r" Writes raw bits to the field"]
847 #[inline]
848 pub fn bit(self, value: bool) -> &'a mut W {
849 const MASK: bool = true;
850 const OFFSET: u8 = 4;
851 self.w.bits &= !((MASK as u32) << OFFSET);
852 self.w.bits |= ((value & MASK) as u32) << OFFSET;
853 self.w
854 }
855}
856#[doc = r" Proxy"]
857pub struct _CTEIF0W<'a> {
858 w: &'a mut W,
859}
860impl<'a> _CTEIF0W<'a> {
861 #[doc = r" Sets the field bit"]
862 pub fn set_bit(self) -> &'a mut W {
863 self.bit(true)
864 }
865 #[doc = r" Clears the field bit"]
866 pub fn clear_bit(self) -> &'a mut W {
867 self.bit(false)
868 }
869 #[doc = r" Writes raw bits to the field"]
870 #[inline]
871 pub fn bit(self, value: bool) -> &'a mut W {
872 const MASK: bool = true;
873 const OFFSET: u8 = 3;
874 self.w.bits &= !((MASK as u32) << OFFSET);
875 self.w.bits |= ((value & MASK) as u32) << OFFSET;
876 self.w
877 }
878}
879#[doc = r" Proxy"]
880pub struct _CDMEIF0W<'a> {
881 w: &'a mut W,
882}
883impl<'a> _CDMEIF0W<'a> {
884 #[doc = r" Sets the field bit"]
885 pub fn set_bit(self) -> &'a mut W {
886 self.bit(true)
887 }
888 #[doc = r" Clears the field bit"]
889 pub fn clear_bit(self) -> &'a mut W {
890 self.bit(false)
891 }
892 #[doc = r" Writes raw bits to the field"]
893 #[inline]
894 pub fn bit(self, value: bool) -> &'a mut W {
895 const MASK: bool = true;
896 const OFFSET: u8 = 2;
897 self.w.bits &= !((MASK as u32) << OFFSET);
898 self.w.bits |= ((value & MASK) as u32) << OFFSET;
899 self.w
900 }
901}
902#[doc = r" Proxy"]
903pub struct _CFEIF0W<'a> {
904 w: &'a mut W,
905}
906impl<'a> _CFEIF0W<'a> {
907 #[doc = r" Sets the field bit"]
908 pub fn set_bit(self) -> &'a mut W {
909 self.bit(true)
910 }
911 #[doc = r" Clears the field bit"]
912 pub fn clear_bit(self) -> &'a mut W {
913 self.bit(false)
914 }
915 #[doc = r" Writes raw bits to the field"]
916 #[inline]
917 pub fn bit(self, value: bool) -> &'a mut W {
918 const MASK: bool = true;
919 const OFFSET: u8 = 0;
920 self.w.bits &= !((MASK as u32) << OFFSET);
921 self.w.bits |= ((value & MASK) as u32) << OFFSET;
922 self.w
923 }
924}
925impl R {
926 #[doc = r" Value of the register as raw bits"]
927 #[inline]
928 pub fn bits(&self) -> u32 {
929 self.bits
930 }
931 #[doc = "Bit 27 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
932 #[inline]
933 pub fn ctcif3(&self) -> CTCIF3R {
934 let bits = {
935 const MASK: bool = true;
936 const OFFSET: u8 = 27;
937 ((self.bits >> OFFSET) & MASK as u32) != 0
938 };
939 CTCIF3R { bits }
940 }
941 #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 3..0)"]
942 #[inline]
943 pub fn chtif3(&self) -> CHTIF3R {
944 let bits = {
945 const MASK: bool = true;
946 const OFFSET: u8 = 26;
947 ((self.bits >> OFFSET) & MASK as u32) != 0
948 };
949 CHTIF3R { bits }
950 }
951 #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 3..0)"]
952 #[inline]
953 pub fn cteif3(&self) -> CTEIF3R {
954 let bits = {
955 const MASK: bool = true;
956 const OFFSET: u8 = 25;
957 ((self.bits >> OFFSET) & MASK as u32) != 0
958 };
959 CTEIF3R { bits }
960 }
961 #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
962 #[inline]
963 pub fn cdmeif3(&self) -> CDMEIF3R {
964 let bits = {
965 const MASK: bool = true;
966 const OFFSET: u8 = 24;
967 ((self.bits >> OFFSET) & MASK as u32) != 0
968 };
969 CDMEIF3R { bits }
970 }
971 #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
972 #[inline]
973 pub fn cfeif3(&self) -> CFEIF3R {
974 let bits = {
975 const MASK: bool = true;
976 const OFFSET: u8 = 22;
977 ((self.bits >> OFFSET) & MASK as u32) != 0
978 };
979 CFEIF3R { bits }
980 }
981 #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
982 #[inline]
983 pub fn ctcif2(&self) -> CTCIF2R {
984 let bits = {
985 const MASK: bool = true;
986 const OFFSET: u8 = 21;
987 ((self.bits >> OFFSET) & MASK as u32) != 0
988 };
989 CTCIF2R { bits }
990 }
991 #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 3..0)"]
992 #[inline]
993 pub fn chtif2(&self) -> CHTIF2R {
994 let bits = {
995 const MASK: bool = true;
996 const OFFSET: u8 = 20;
997 ((self.bits >> OFFSET) & MASK as u32) != 0
998 };
999 CHTIF2R { bits }
1000 }
1001 #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1002 #[inline]
1003 pub fn cteif2(&self) -> CTEIF2R {
1004 let bits = {
1005 const MASK: bool = true;
1006 const OFFSET: u8 = 19;
1007 ((self.bits >> OFFSET) & MASK as u32) != 0
1008 };
1009 CTEIF2R { bits }
1010 }
1011 #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1012 #[inline]
1013 pub fn cdmeif2(&self) -> CDMEIF2R {
1014 let bits = {
1015 const MASK: bool = true;
1016 const OFFSET: u8 = 18;
1017 ((self.bits >> OFFSET) & MASK as u32) != 0
1018 };
1019 CDMEIF2R { bits }
1020 }
1021 #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1022 #[inline]
1023 pub fn cfeif2(&self) -> CFEIF2R {
1024 let bits = {
1025 const MASK: bool = true;
1026 const OFFSET: u8 = 16;
1027 ((self.bits >> OFFSET) & MASK as u32) != 0
1028 };
1029 CFEIF2R { bits }
1030 }
1031 #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1032 #[inline]
1033 pub fn ctcif1(&self) -> CTCIF1R {
1034 let bits = {
1035 const MASK: bool = true;
1036 const OFFSET: u8 = 11;
1037 ((self.bits >> OFFSET) & MASK as u32) != 0
1038 };
1039 CTCIF1R { bits }
1040 }
1041 #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1042 #[inline]
1043 pub fn chtif1(&self) -> CHTIF1R {
1044 let bits = {
1045 const MASK: bool = true;
1046 const OFFSET: u8 = 10;
1047 ((self.bits >> OFFSET) & MASK as u32) != 0
1048 };
1049 CHTIF1R { bits }
1050 }
1051 #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1052 #[inline]
1053 pub fn cteif1(&self) -> CTEIF1R {
1054 let bits = {
1055 const MASK: bool = true;
1056 const OFFSET: u8 = 9;
1057 ((self.bits >> OFFSET) & MASK as u32) != 0
1058 };
1059 CTEIF1R { bits }
1060 }
1061 #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1062 #[inline]
1063 pub fn cdmeif1(&self) -> CDMEIF1R {
1064 let bits = {
1065 const MASK: bool = true;
1066 const OFFSET: u8 = 8;
1067 ((self.bits >> OFFSET) & MASK as u32) != 0
1068 };
1069 CDMEIF1R { bits }
1070 }
1071 #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1072 #[inline]
1073 pub fn cfeif1(&self) -> CFEIF1R {
1074 let bits = {
1075 const MASK: bool = true;
1076 const OFFSET: u8 = 6;
1077 ((self.bits >> OFFSET) & MASK as u32) != 0
1078 };
1079 CFEIF1R { bits }
1080 }
1081 #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1082 #[inline]
1083 pub fn ctcif0(&self) -> CTCIF0R {
1084 let bits = {
1085 const MASK: bool = true;
1086 const OFFSET: u8 = 5;
1087 ((self.bits >> OFFSET) & MASK as u32) != 0
1088 };
1089 CTCIF0R { bits }
1090 }
1091 #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1092 #[inline]
1093 pub fn chtif0(&self) -> CHTIF0R {
1094 let bits = {
1095 const MASK: bool = true;
1096 const OFFSET: u8 = 4;
1097 ((self.bits >> OFFSET) & MASK as u32) != 0
1098 };
1099 CHTIF0R { bits }
1100 }
1101 #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1102 #[inline]
1103 pub fn cteif0(&self) -> CTEIF0R {
1104 let bits = {
1105 const MASK: bool = true;
1106 const OFFSET: u8 = 3;
1107 ((self.bits >> OFFSET) & MASK as u32) != 0
1108 };
1109 CTEIF0R { bits }
1110 }
1111 #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1112 #[inline]
1113 pub fn cdmeif0(&self) -> CDMEIF0R {
1114 let bits = {
1115 const MASK: bool = true;
1116 const OFFSET: u8 = 2;
1117 ((self.bits >> OFFSET) & MASK as u32) != 0
1118 };
1119 CDMEIF0R { bits }
1120 }
1121 #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1122 #[inline]
1123 pub fn cfeif0(&self) -> CFEIF0R {
1124 let bits = {
1125 const MASK: bool = true;
1126 const OFFSET: u8 = 0;
1127 ((self.bits >> OFFSET) & MASK as u32) != 0
1128 };
1129 CFEIF0R { bits }
1130 }
1131}
1132impl W {
1133 #[doc = r" Reset value of the register"]
1134 #[inline]
1135 pub fn reset_value() -> W {
1136 W { bits: 0 }
1137 }
1138 #[doc = r" Writes raw bits to the register"]
1139 #[inline]
1140 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1141 self.bits = bits;
1142 self
1143 }
1144 #[doc = "Bit 27 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1145 #[inline]
1146 pub fn ctcif3(&mut self) -> _CTCIF3W {
1147 _CTCIF3W { w: self }
1148 }
1149 #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1150 #[inline]
1151 pub fn chtif3(&mut self) -> _CHTIF3W {
1152 _CHTIF3W { w: self }
1153 }
1154 #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1155 #[inline]
1156 pub fn cteif3(&mut self) -> _CTEIF3W {
1157 _CTEIF3W { w: self }
1158 }
1159 #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1160 #[inline]
1161 pub fn cdmeif3(&mut self) -> _CDMEIF3W {
1162 _CDMEIF3W { w: self }
1163 }
1164 #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1165 #[inline]
1166 pub fn cfeif3(&mut self) -> _CFEIF3W {
1167 _CFEIF3W { w: self }
1168 }
1169 #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1170 #[inline]
1171 pub fn ctcif2(&mut self) -> _CTCIF2W {
1172 _CTCIF2W { w: self }
1173 }
1174 #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1175 #[inline]
1176 pub fn chtif2(&mut self) -> _CHTIF2W {
1177 _CHTIF2W { w: self }
1178 }
1179 #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1180 #[inline]
1181 pub fn cteif2(&mut self) -> _CTEIF2W {
1182 _CTEIF2W { w: self }
1183 }
1184 #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1185 #[inline]
1186 pub fn cdmeif2(&mut self) -> _CDMEIF2W {
1187 _CDMEIF2W { w: self }
1188 }
1189 #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1190 #[inline]
1191 pub fn cfeif2(&mut self) -> _CFEIF2W {
1192 _CFEIF2W { w: self }
1193 }
1194 #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1195 #[inline]
1196 pub fn ctcif1(&mut self) -> _CTCIF1W {
1197 _CTCIF1W { w: self }
1198 }
1199 #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1200 #[inline]
1201 pub fn chtif1(&mut self) -> _CHTIF1W {
1202 _CHTIF1W { w: self }
1203 }
1204 #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1205 #[inline]
1206 pub fn cteif1(&mut self) -> _CTEIF1W {
1207 _CTEIF1W { w: self }
1208 }
1209 #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1210 #[inline]
1211 pub fn cdmeif1(&mut self) -> _CDMEIF1W {
1212 _CDMEIF1W { w: self }
1213 }
1214 #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1215 #[inline]
1216 pub fn cfeif1(&mut self) -> _CFEIF1W {
1217 _CFEIF1W { w: self }
1218 }
1219 #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 3..0)"]
1220 #[inline]
1221 pub fn ctcif0(&mut self) -> _CTCIF0W {
1222 _CTCIF0W { w: self }
1223 }
1224 #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 3..0)"]
1225 #[inline]
1226 pub fn chtif0(&mut self) -> _CHTIF0W {
1227 _CHTIF0W { w: self }
1228 }
1229 #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 3..0)"]
1230 #[inline]
1231 pub fn cteif0(&mut self) -> _CTEIF0W {
1232 _CTEIF0W { w: self }
1233 }
1234 #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 3..0)"]
1235 #[inline]
1236 pub fn cdmeif0(&mut self) -> _CDMEIF0W {
1237 _CDMEIF0W { w: self }
1238 }
1239 #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 3..0)"]
1240 #[inline]
1241 pub fn cfeif0(&mut self) -> _CFEIF0W {
1242 _CFEIF0W { w: self }
1243 }
1244}