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::IMR {
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 { bits: self.register.get() }
26 }
27 #[doc = r" Writes to the register"]
28 #[inline]
29 pub fn write<F>(&self, f: F)
30 where
31 F: FnOnce(&mut W) -> &mut W,
32 {
33 let mut w = W::reset_value();
34 f(&mut w);
35 self.register.set(w.bits);
36 }
37 #[doc = r" Writes the reset value to the register"]
38 #[inline]
39 pub fn reset(&self) {
40 self.write(|w| w)
41 }
42}
43#[doc = r" Value of the field"]
44pub struct RESERVED14R {
45 bits: u32,
46}
47impl RESERVED14R {
48 #[doc = r" Value of the field as raw bits"]
49 #[inline]
50 pub fn bits(&self) -> u32 {
51 self.bits
52 }
53}
54#[doc = "Possible values of the field `DMABIM`"]
55#[derive(Clone, Copy, Debug, PartialEq)]
56pub enum DMABIMR {
57 #[doc = "Enable Interrupt"]
58 EN,
59 #[doc = "Disable Interrupt"]
60 DIS,
61}
62impl DMABIMR {
63 #[doc = r" Returns `true` if the bit is clear (0)"]
64 #[inline]
65 pub fn bit_is_clear(&self) -> bool {
66 !self.bit()
67 }
68 #[doc = r" Returns `true` if the bit is set (1)"]
69 #[inline]
70 pub fn bit_is_set(&self) -> bool {
71 self.bit()
72 }
73 #[doc = r" Value of the field as raw bits"]
74 #[inline]
75 pub fn bit(&self) -> bool {
76 match *self {
77 DMABIMR::EN => true,
78 DMABIMR::DIS => false,
79 }
80 }
81 #[allow(missing_docs)]
82 #[doc(hidden)]
83 #[inline]
84 pub fn _from(value: bool) -> DMABIMR {
85 match value {
86 true => DMABIMR::EN,
87 false => DMABIMR::DIS,
88 }
89 }
90 #[doc = "Checks if the value of the field is `EN`"]
91 #[inline]
92 pub fn is_en(&self) -> bool {
93 *self == DMABIMR::EN
94 }
95 #[doc = "Checks if the value of the field is `DIS`"]
96 #[inline]
97 pub fn is_dis(&self) -> bool {
98 *self == DMABIMR::DIS
99 }
100}
101#[doc = r" Value of the field"]
102pub struct RESERVED12R {
103 bits: bool,
104}
105impl RESERVED12R {
106 #[doc = r" Value of the field as raw bits"]
107 #[inline]
108 pub fn bit(&self) -> bool {
109 self.bits
110 }
111 #[doc = r" Returns `true` if the bit is clear (0)"]
112 #[inline]
113 pub fn bit_is_clear(&self) -> bool {
114 !self.bit()
115 }
116 #[doc = r" Returns `true` if the bit is set (1)"]
117 #[inline]
118 pub fn bit_is_set(&self) -> bool {
119 self.bit()
120 }
121}
122#[doc = "Possible values of the field `TBMIM`"]
123#[derive(Clone, Copy, Debug, PartialEq)]
124pub enum TBMIMR {
125 #[doc = "Enable Interrupt"]
126 EN,
127 #[doc = "Disable Interrupt"]
128 DIS,
129}
130impl TBMIMR {
131 #[doc = r" Returns `true` if the bit is clear (0)"]
132 #[inline]
133 pub fn bit_is_clear(&self) -> bool {
134 !self.bit()
135 }
136 #[doc = r" Returns `true` if the bit is set (1)"]
137 #[inline]
138 pub fn bit_is_set(&self) -> bool {
139 self.bit()
140 }
141 #[doc = r" Value of the field as raw bits"]
142 #[inline]
143 pub fn bit(&self) -> bool {
144 match *self {
145 TBMIMR::EN => true,
146 TBMIMR::DIS => false,
147 }
148 }
149 #[allow(missing_docs)]
150 #[doc(hidden)]
151 #[inline]
152 pub fn _from(value: bool) -> TBMIMR {
153 match value {
154 true => TBMIMR::EN,
155 false => TBMIMR::DIS,
156 }
157 }
158 #[doc = "Checks if the value of the field is `EN`"]
159 #[inline]
160 pub fn is_en(&self) -> bool {
161 *self == TBMIMR::EN
162 }
163 #[doc = "Checks if the value of the field is `DIS`"]
164 #[inline]
165 pub fn is_dis(&self) -> bool {
166 *self == TBMIMR::DIS
167 }
168}
169#[doc = "Possible values of the field `CBEIM`"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum CBEIMR {
172 #[doc = "Enable Interrupt"]
173 EN,
174 #[doc = "Disable Interrupt"]
175 DIS,
176}
177impl CBEIMR {
178 #[doc = r" Returns `true` if the bit is clear (0)"]
179 #[inline]
180 pub fn bit_is_clear(&self) -> bool {
181 !self.bit()
182 }
183 #[doc = r" Returns `true` if the bit is set (1)"]
184 #[inline]
185 pub fn bit_is_set(&self) -> bool {
186 self.bit()
187 }
188 #[doc = r" Value of the field as raw bits"]
189 #[inline]
190 pub fn bit(&self) -> bool {
191 match *self {
192 CBEIMR::EN => true,
193 CBEIMR::DIS => false,
194 }
195 }
196 #[allow(missing_docs)]
197 #[doc(hidden)]
198 #[inline]
199 pub fn _from(value: bool) -> CBEIMR {
200 match value {
201 true => CBEIMR::EN,
202 false => CBEIMR::DIS,
203 }
204 }
205 #[doc = "Checks if the value of the field is `EN`"]
206 #[inline]
207 pub fn is_en(&self) -> bool {
208 *self == CBEIMR::EN
209 }
210 #[doc = "Checks if the value of the field is `DIS`"]
211 #[inline]
212 pub fn is_dis(&self) -> bool {
213 *self == CBEIMR::DIS
214 }
215}
216#[doc = "Possible values of the field `CBMIM`"]
217#[derive(Clone, Copy, Debug, PartialEq)]
218pub enum CBMIMR {
219 #[doc = "Enable Interrupt"]
220 EN,
221 #[doc = "Disable Interrupt"]
222 DIS,
223}
224impl CBMIMR {
225 #[doc = r" Returns `true` if the bit is clear (0)"]
226 #[inline]
227 pub fn bit_is_clear(&self) -> bool {
228 !self.bit()
229 }
230 #[doc = r" Returns `true` if the bit is set (1)"]
231 #[inline]
232 pub fn bit_is_set(&self) -> bool {
233 self.bit()
234 }
235 #[doc = r" Value of the field as raw bits"]
236 #[inline]
237 pub fn bit(&self) -> bool {
238 match *self {
239 CBMIMR::EN => true,
240 CBMIMR::DIS => false,
241 }
242 }
243 #[allow(missing_docs)]
244 #[doc(hidden)]
245 #[inline]
246 pub fn _from(value: bool) -> CBMIMR {
247 match value {
248 true => CBMIMR::EN,
249 false => CBMIMR::DIS,
250 }
251 }
252 #[doc = "Checks if the value of the field is `EN`"]
253 #[inline]
254 pub fn is_en(&self) -> bool {
255 *self == CBMIMR::EN
256 }
257 #[doc = "Checks if the value of the field is `DIS`"]
258 #[inline]
259 pub fn is_dis(&self) -> bool {
260 *self == CBMIMR::DIS
261 }
262}
263#[doc = "Possible values of the field `TBTOIM`"]
264#[derive(Clone, Copy, Debug, PartialEq)]
265pub enum TBTOIMR {
266 #[doc = "Enable Interrupt"]
267 EN,
268 #[doc = "Disable Interrupt"]
269 DIS,
270}
271impl TBTOIMR {
272 #[doc = r" Returns `true` if the bit is clear (0)"]
273 #[inline]
274 pub fn bit_is_clear(&self) -> bool {
275 !self.bit()
276 }
277 #[doc = r" Returns `true` if the bit is set (1)"]
278 #[inline]
279 pub fn bit_is_set(&self) -> bool {
280 self.bit()
281 }
282 #[doc = r" Value of the field as raw bits"]
283 #[inline]
284 pub fn bit(&self) -> bool {
285 match *self {
286 TBTOIMR::EN => true,
287 TBTOIMR::DIS => false,
288 }
289 }
290 #[allow(missing_docs)]
291 #[doc(hidden)]
292 #[inline]
293 pub fn _from(value: bool) -> TBTOIMR {
294 match value {
295 true => TBTOIMR::EN,
296 false => TBTOIMR::DIS,
297 }
298 }
299 #[doc = "Checks if the value of the field is `EN`"]
300 #[inline]
301 pub fn is_en(&self) -> bool {
302 *self == TBTOIMR::EN
303 }
304 #[doc = "Checks if the value of the field is `DIS`"]
305 #[inline]
306 pub fn is_dis(&self) -> bool {
307 *self == TBTOIMR::DIS
308 }
309}
310#[doc = r" Value of the field"]
311pub struct RESERVED6R {
312 bits: u8,
313}
314impl RESERVED6R {
315 #[doc = r" Value of the field as raw bits"]
316 #[inline]
317 pub fn bits(&self) -> u8 {
318 self.bits
319 }
320}
321#[doc = "Possible values of the field `DMAAIM`"]
322#[derive(Clone, Copy, Debug, PartialEq)]
323pub enum DMAAIMR {
324 #[doc = "Enable Interrupt"]
325 EN,
326 #[doc = "Disable Interrupt"]
327 DIS,
328}
329impl DMAAIMR {
330 #[doc = r" Returns `true` if the bit is clear (0)"]
331 #[inline]
332 pub fn bit_is_clear(&self) -> bool {
333 !self.bit()
334 }
335 #[doc = r" Returns `true` if the bit is set (1)"]
336 #[inline]
337 pub fn bit_is_set(&self) -> bool {
338 self.bit()
339 }
340 #[doc = r" Value of the field as raw bits"]
341 #[inline]
342 pub fn bit(&self) -> bool {
343 match *self {
344 DMAAIMR::EN => true,
345 DMAAIMR::DIS => false,
346 }
347 }
348 #[allow(missing_docs)]
349 #[doc(hidden)]
350 #[inline]
351 pub fn _from(value: bool) -> DMAAIMR {
352 match value {
353 true => DMAAIMR::EN,
354 false => DMAAIMR::DIS,
355 }
356 }
357 #[doc = "Checks if the value of the field is `EN`"]
358 #[inline]
359 pub fn is_en(&self) -> bool {
360 *self == DMAAIMR::EN
361 }
362 #[doc = "Checks if the value of the field is `DIS`"]
363 #[inline]
364 pub fn is_dis(&self) -> bool {
365 *self == DMAAIMR::DIS
366 }
367}
368#[doc = "Possible values of the field `TAMIM`"]
369#[derive(Clone, Copy, Debug, PartialEq)]
370pub enum TAMIMR {
371 #[doc = "Enable Interrupt"]
372 EN,
373 #[doc = "Disable Interrupt"]
374 DIS,
375}
376impl TAMIMR {
377 #[doc = r" Returns `true` if the bit is clear (0)"]
378 #[inline]
379 pub fn bit_is_clear(&self) -> bool {
380 !self.bit()
381 }
382 #[doc = r" Returns `true` if the bit is set (1)"]
383 #[inline]
384 pub fn bit_is_set(&self) -> bool {
385 self.bit()
386 }
387 #[doc = r" Value of the field as raw bits"]
388 #[inline]
389 pub fn bit(&self) -> bool {
390 match *self {
391 TAMIMR::EN => true,
392 TAMIMR::DIS => false,
393 }
394 }
395 #[allow(missing_docs)]
396 #[doc(hidden)]
397 #[inline]
398 pub fn _from(value: bool) -> TAMIMR {
399 match value {
400 true => TAMIMR::EN,
401 false => TAMIMR::DIS,
402 }
403 }
404 #[doc = "Checks if the value of the field is `EN`"]
405 #[inline]
406 pub fn is_en(&self) -> bool {
407 *self == TAMIMR::EN
408 }
409 #[doc = "Checks if the value of the field is `DIS`"]
410 #[inline]
411 pub fn is_dis(&self) -> bool {
412 *self == TAMIMR::DIS
413 }
414}
415#[doc = r" Value of the field"]
416pub struct RESERVED3R {
417 bits: bool,
418}
419impl RESERVED3R {
420 #[doc = r" Value of the field as raw bits"]
421 #[inline]
422 pub fn bit(&self) -> bool {
423 self.bits
424 }
425 #[doc = r" Returns `true` if the bit is clear (0)"]
426 #[inline]
427 pub fn bit_is_clear(&self) -> bool {
428 !self.bit()
429 }
430 #[doc = r" Returns `true` if the bit is set (1)"]
431 #[inline]
432 pub fn bit_is_set(&self) -> bool {
433 self.bit()
434 }
435}
436#[doc = "Possible values of the field `CAEIM`"]
437#[derive(Clone, Copy, Debug, PartialEq)]
438pub enum CAEIMR {
439 #[doc = "Enable Interrupt"]
440 EN,
441 #[doc = "Disable Interrupt"]
442 DIS,
443}
444impl CAEIMR {
445 #[doc = r" Returns `true` if the bit is clear (0)"]
446 #[inline]
447 pub fn bit_is_clear(&self) -> bool {
448 !self.bit()
449 }
450 #[doc = r" Returns `true` if the bit is set (1)"]
451 #[inline]
452 pub fn bit_is_set(&self) -> bool {
453 self.bit()
454 }
455 #[doc = r" Value of the field as raw bits"]
456 #[inline]
457 pub fn bit(&self) -> bool {
458 match *self {
459 CAEIMR::EN => true,
460 CAEIMR::DIS => false,
461 }
462 }
463 #[allow(missing_docs)]
464 #[doc(hidden)]
465 #[inline]
466 pub fn _from(value: bool) -> CAEIMR {
467 match value {
468 true => CAEIMR::EN,
469 false => CAEIMR::DIS,
470 }
471 }
472 #[doc = "Checks if the value of the field is `EN`"]
473 #[inline]
474 pub fn is_en(&self) -> bool {
475 *self == CAEIMR::EN
476 }
477 #[doc = "Checks if the value of the field is `DIS`"]
478 #[inline]
479 pub fn is_dis(&self) -> bool {
480 *self == CAEIMR::DIS
481 }
482}
483#[doc = "Possible values of the field `CAMIM`"]
484#[derive(Clone, Copy, Debug, PartialEq)]
485pub enum CAMIMR {
486 #[doc = "Enable Interrupt"]
487 EN,
488 #[doc = "Disable Interrupt"]
489 DIS,
490}
491impl CAMIMR {
492 #[doc = r" Returns `true` if the bit is clear (0)"]
493 #[inline]
494 pub fn bit_is_clear(&self) -> bool {
495 !self.bit()
496 }
497 #[doc = r" Returns `true` if the bit is set (1)"]
498 #[inline]
499 pub fn bit_is_set(&self) -> bool {
500 self.bit()
501 }
502 #[doc = r" Value of the field as raw bits"]
503 #[inline]
504 pub fn bit(&self) -> bool {
505 match *self {
506 CAMIMR::EN => true,
507 CAMIMR::DIS => false,
508 }
509 }
510 #[allow(missing_docs)]
511 #[doc(hidden)]
512 #[inline]
513 pub fn _from(value: bool) -> CAMIMR {
514 match value {
515 true => CAMIMR::EN,
516 false => CAMIMR::DIS,
517 }
518 }
519 #[doc = "Checks if the value of the field is `EN`"]
520 #[inline]
521 pub fn is_en(&self) -> bool {
522 *self == CAMIMR::EN
523 }
524 #[doc = "Checks if the value of the field is `DIS`"]
525 #[inline]
526 pub fn is_dis(&self) -> bool {
527 *self == CAMIMR::DIS
528 }
529}
530#[doc = "Possible values of the field `TATOIM`"]
531#[derive(Clone, Copy, Debug, PartialEq)]
532pub enum TATOIMR {
533 #[doc = "Enable Interrupt"]
534 EN,
535 #[doc = "Disable Interrupt"]
536 DIS,
537}
538impl TATOIMR {
539 #[doc = r" Returns `true` if the bit is clear (0)"]
540 #[inline]
541 pub fn bit_is_clear(&self) -> bool {
542 !self.bit()
543 }
544 #[doc = r" Returns `true` if the bit is set (1)"]
545 #[inline]
546 pub fn bit_is_set(&self) -> bool {
547 self.bit()
548 }
549 #[doc = r" Value of the field as raw bits"]
550 #[inline]
551 pub fn bit(&self) -> bool {
552 match *self {
553 TATOIMR::EN => true,
554 TATOIMR::DIS => false,
555 }
556 }
557 #[allow(missing_docs)]
558 #[doc(hidden)]
559 #[inline]
560 pub fn _from(value: bool) -> TATOIMR {
561 match value {
562 true => TATOIMR::EN,
563 false => TATOIMR::DIS,
564 }
565 }
566 #[doc = "Checks if the value of the field is `EN`"]
567 #[inline]
568 pub fn is_en(&self) -> bool {
569 *self == TATOIMR::EN
570 }
571 #[doc = "Checks if the value of the field is `DIS`"]
572 #[inline]
573 pub fn is_dis(&self) -> bool {
574 *self == TATOIMR::DIS
575 }
576}
577#[doc = "Values that can be written to the field `DMABIM`"]
578#[derive(Clone, Copy, Debug, PartialEq)]
579pub enum DMABIMW {
580 #[doc = "Enable Interrupt"]
581 EN,
582 #[doc = "Disable Interrupt"]
583 DIS,
584}
585impl DMABIMW {
586 #[allow(missing_docs)]
587 #[doc(hidden)]
588 #[inline]
589 pub fn _bits(&self) -> bool {
590 match *self {
591 DMABIMW::EN => true,
592 DMABIMW::DIS => false,
593 }
594 }
595}
596#[doc = r" Proxy"]
597pub struct _DMABIMW<'a> {
598 w: &'a mut W,
599}
600impl<'a> _DMABIMW<'a> {
601 #[doc = r" Writes `variant` to the field"]
602 #[inline]
603 pub fn variant(self, variant: DMABIMW) -> &'a mut W {
604 {
605 self.bit(variant._bits())
606 }
607 }
608 #[doc = "Enable Interrupt"]
609 #[inline]
610 pub fn en(self) -> &'a mut W {
611 self.variant(DMABIMW::EN)
612 }
613 #[doc = "Disable Interrupt"]
614 #[inline]
615 pub fn dis(self) -> &'a mut W {
616 self.variant(DMABIMW::DIS)
617 }
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 = "Values that can be written to the field `TBMIM`"]
637#[derive(Clone, Copy, Debug, PartialEq)]
638pub enum TBMIMW {
639 #[doc = "Enable Interrupt"]
640 EN,
641 #[doc = "Disable Interrupt"]
642 DIS,
643}
644impl TBMIMW {
645 #[allow(missing_docs)]
646 #[doc(hidden)]
647 #[inline]
648 pub fn _bits(&self) -> bool {
649 match *self {
650 TBMIMW::EN => true,
651 TBMIMW::DIS => false,
652 }
653 }
654}
655#[doc = r" Proxy"]
656pub struct _TBMIMW<'a> {
657 w: &'a mut W,
658}
659impl<'a> _TBMIMW<'a> {
660 #[doc = r" Writes `variant` to the field"]
661 #[inline]
662 pub fn variant(self, variant: TBMIMW) -> &'a mut W {
663 {
664 self.bit(variant._bits())
665 }
666 }
667 #[doc = "Enable Interrupt"]
668 #[inline]
669 pub fn en(self) -> &'a mut W {
670 self.variant(TBMIMW::EN)
671 }
672 #[doc = "Disable Interrupt"]
673 #[inline]
674 pub fn dis(self) -> &'a mut W {
675 self.variant(TBMIMW::DIS)
676 }
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 = 11;
690 self.w.bits &= !((MASK as u32) << OFFSET);
691 self.w.bits |= ((value & MASK) as u32) << OFFSET;
692 self.w
693 }
694}
695#[doc = "Values that can be written to the field `CBEIM`"]
696#[derive(Clone, Copy, Debug, PartialEq)]
697pub enum CBEIMW {
698 #[doc = "Enable Interrupt"]
699 EN,
700 #[doc = "Disable Interrupt"]
701 DIS,
702}
703impl CBEIMW {
704 #[allow(missing_docs)]
705 #[doc(hidden)]
706 #[inline]
707 pub fn _bits(&self) -> bool {
708 match *self {
709 CBEIMW::EN => true,
710 CBEIMW::DIS => false,
711 }
712 }
713}
714#[doc = r" Proxy"]
715pub struct _CBEIMW<'a> {
716 w: &'a mut W,
717}
718impl<'a> _CBEIMW<'a> {
719 #[doc = r" Writes `variant` to the field"]
720 #[inline]
721 pub fn variant(self, variant: CBEIMW) -> &'a mut W {
722 {
723 self.bit(variant._bits())
724 }
725 }
726 #[doc = "Enable Interrupt"]
727 #[inline]
728 pub fn en(self) -> &'a mut W {
729 self.variant(CBEIMW::EN)
730 }
731 #[doc = "Disable Interrupt"]
732 #[inline]
733 pub fn dis(self) -> &'a mut W {
734 self.variant(CBEIMW::DIS)
735 }
736 #[doc = r" Sets the field bit"]
737 pub fn set_bit(self) -> &'a mut W {
738 self.bit(true)
739 }
740 #[doc = r" Clears the field bit"]
741 pub fn clear_bit(self) -> &'a mut W {
742 self.bit(false)
743 }
744 #[doc = r" Writes raw bits to the field"]
745 #[inline]
746 pub fn bit(self, value: bool) -> &'a mut W {
747 const MASK: bool = true;
748 const OFFSET: u8 = 10;
749 self.w.bits &= !((MASK as u32) << OFFSET);
750 self.w.bits |= ((value & MASK) as u32) << OFFSET;
751 self.w
752 }
753}
754#[doc = "Values that can be written to the field `CBMIM`"]
755#[derive(Clone, Copy, Debug, PartialEq)]
756pub enum CBMIMW {
757 #[doc = "Enable Interrupt"]
758 EN,
759 #[doc = "Disable Interrupt"]
760 DIS,
761}
762impl CBMIMW {
763 #[allow(missing_docs)]
764 #[doc(hidden)]
765 #[inline]
766 pub fn _bits(&self) -> bool {
767 match *self {
768 CBMIMW::EN => true,
769 CBMIMW::DIS => false,
770 }
771 }
772}
773#[doc = r" Proxy"]
774pub struct _CBMIMW<'a> {
775 w: &'a mut W,
776}
777impl<'a> _CBMIMW<'a> {
778 #[doc = r" Writes `variant` to the field"]
779 #[inline]
780 pub fn variant(self, variant: CBMIMW) -> &'a mut W {
781 {
782 self.bit(variant._bits())
783 }
784 }
785 #[doc = "Enable Interrupt"]
786 #[inline]
787 pub fn en(self) -> &'a mut W {
788 self.variant(CBMIMW::EN)
789 }
790 #[doc = "Disable Interrupt"]
791 #[inline]
792 pub fn dis(self) -> &'a mut W {
793 self.variant(CBMIMW::DIS)
794 }
795 #[doc = r" Sets the field bit"]
796 pub fn set_bit(self) -> &'a mut W {
797 self.bit(true)
798 }
799 #[doc = r" Clears the field bit"]
800 pub fn clear_bit(self) -> &'a mut W {
801 self.bit(false)
802 }
803 #[doc = r" Writes raw bits to the field"]
804 #[inline]
805 pub fn bit(self, value: bool) -> &'a mut W {
806 const MASK: bool = true;
807 const OFFSET: u8 = 9;
808 self.w.bits &= !((MASK as u32) << OFFSET);
809 self.w.bits |= ((value & MASK) as u32) << OFFSET;
810 self.w
811 }
812}
813#[doc = "Values that can be written to the field `TBTOIM`"]
814#[derive(Clone, Copy, Debug, PartialEq)]
815pub enum TBTOIMW {
816 #[doc = "Enable Interrupt"]
817 EN,
818 #[doc = "Disable Interrupt"]
819 DIS,
820}
821impl TBTOIMW {
822 #[allow(missing_docs)]
823 #[doc(hidden)]
824 #[inline]
825 pub fn _bits(&self) -> bool {
826 match *self {
827 TBTOIMW::EN => true,
828 TBTOIMW::DIS => false,
829 }
830 }
831}
832#[doc = r" Proxy"]
833pub struct _TBTOIMW<'a> {
834 w: &'a mut W,
835}
836impl<'a> _TBTOIMW<'a> {
837 #[doc = r" Writes `variant` to the field"]
838 #[inline]
839 pub fn variant(self, variant: TBTOIMW) -> &'a mut W {
840 {
841 self.bit(variant._bits())
842 }
843 }
844 #[doc = "Enable Interrupt"]
845 #[inline]
846 pub fn en(self) -> &'a mut W {
847 self.variant(TBTOIMW::EN)
848 }
849 #[doc = "Disable Interrupt"]
850 #[inline]
851 pub fn dis(self) -> &'a mut W {
852 self.variant(TBTOIMW::DIS)
853 }
854 #[doc = r" Sets the field bit"]
855 pub fn set_bit(self) -> &'a mut W {
856 self.bit(true)
857 }
858 #[doc = r" Clears the field bit"]
859 pub fn clear_bit(self) -> &'a mut W {
860 self.bit(false)
861 }
862 #[doc = r" Writes raw bits to the field"]
863 #[inline]
864 pub fn bit(self, value: bool) -> &'a mut W {
865 const MASK: bool = true;
866 const OFFSET: u8 = 8;
867 self.w.bits &= !((MASK as u32) << OFFSET);
868 self.w.bits |= ((value & MASK) as u32) << OFFSET;
869 self.w
870 }
871}
872#[doc = "Values that can be written to the field `DMAAIM`"]
873#[derive(Clone, Copy, Debug, PartialEq)]
874pub enum DMAAIMW {
875 #[doc = "Enable Interrupt"]
876 EN,
877 #[doc = "Disable Interrupt"]
878 DIS,
879}
880impl DMAAIMW {
881 #[allow(missing_docs)]
882 #[doc(hidden)]
883 #[inline]
884 pub fn _bits(&self) -> bool {
885 match *self {
886 DMAAIMW::EN => true,
887 DMAAIMW::DIS => false,
888 }
889 }
890}
891#[doc = r" Proxy"]
892pub struct _DMAAIMW<'a> {
893 w: &'a mut W,
894}
895impl<'a> _DMAAIMW<'a> {
896 #[doc = r" Writes `variant` to the field"]
897 #[inline]
898 pub fn variant(self, variant: DMAAIMW) -> &'a mut W {
899 {
900 self.bit(variant._bits())
901 }
902 }
903 #[doc = "Enable Interrupt"]
904 #[inline]
905 pub fn en(self) -> &'a mut W {
906 self.variant(DMAAIMW::EN)
907 }
908 #[doc = "Disable Interrupt"]
909 #[inline]
910 pub fn dis(self) -> &'a mut W {
911 self.variant(DMAAIMW::DIS)
912 }
913 #[doc = r" Sets the field bit"]
914 pub fn set_bit(self) -> &'a mut W {
915 self.bit(true)
916 }
917 #[doc = r" Clears the field bit"]
918 pub fn clear_bit(self) -> &'a mut W {
919 self.bit(false)
920 }
921 #[doc = r" Writes raw bits to the field"]
922 #[inline]
923 pub fn bit(self, value: bool) -> &'a mut W {
924 const MASK: bool = true;
925 const OFFSET: u8 = 5;
926 self.w.bits &= !((MASK as u32) << OFFSET);
927 self.w.bits |= ((value & MASK) as u32) << OFFSET;
928 self.w
929 }
930}
931#[doc = "Values that can be written to the field `TAMIM`"]
932#[derive(Clone, Copy, Debug, PartialEq)]
933pub enum TAMIMW {
934 #[doc = "Enable Interrupt"]
935 EN,
936 #[doc = "Disable Interrupt"]
937 DIS,
938}
939impl TAMIMW {
940 #[allow(missing_docs)]
941 #[doc(hidden)]
942 #[inline]
943 pub fn _bits(&self) -> bool {
944 match *self {
945 TAMIMW::EN => true,
946 TAMIMW::DIS => false,
947 }
948 }
949}
950#[doc = r" Proxy"]
951pub struct _TAMIMW<'a> {
952 w: &'a mut W,
953}
954impl<'a> _TAMIMW<'a> {
955 #[doc = r" Writes `variant` to the field"]
956 #[inline]
957 pub fn variant(self, variant: TAMIMW) -> &'a mut W {
958 {
959 self.bit(variant._bits())
960 }
961 }
962 #[doc = "Enable Interrupt"]
963 #[inline]
964 pub fn en(self) -> &'a mut W {
965 self.variant(TAMIMW::EN)
966 }
967 #[doc = "Disable Interrupt"]
968 #[inline]
969 pub fn dis(self) -> &'a mut W {
970 self.variant(TAMIMW::DIS)
971 }
972 #[doc = r" Sets the field bit"]
973 pub fn set_bit(self) -> &'a mut W {
974 self.bit(true)
975 }
976 #[doc = r" Clears the field bit"]
977 pub fn clear_bit(self) -> &'a mut W {
978 self.bit(false)
979 }
980 #[doc = r" Writes raw bits to the field"]
981 #[inline]
982 pub fn bit(self, value: bool) -> &'a mut W {
983 const MASK: bool = true;
984 const OFFSET: u8 = 4;
985 self.w.bits &= !((MASK as u32) << OFFSET);
986 self.w.bits |= ((value & MASK) as u32) << OFFSET;
987 self.w
988 }
989}
990#[doc = r" Proxy"]
991pub struct _RESERVED3W<'a> {
992 w: &'a mut W,
993}
994impl<'a> _RESERVED3W<'a> {
995 #[doc = r" Sets the field bit"]
996 pub fn set_bit(self) -> &'a mut W {
997 self.bit(true)
998 }
999 #[doc = r" Clears the field bit"]
1000 pub fn clear_bit(self) -> &'a mut W {
1001 self.bit(false)
1002 }
1003 #[doc = r" Writes raw bits to the field"]
1004 #[inline]
1005 pub fn bit(self, value: bool) -> &'a mut W {
1006 const MASK: bool = true;
1007 const OFFSET: u8 = 3;
1008 self.w.bits &= !((MASK as u32) << OFFSET);
1009 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1010 self.w
1011 }
1012}
1013#[doc = "Values that can be written to the field `CAEIM`"]
1014#[derive(Clone, Copy, Debug, PartialEq)]
1015pub enum CAEIMW {
1016 #[doc = "Enable Interrupt"]
1017 EN,
1018 #[doc = "Disable Interrupt"]
1019 DIS,
1020}
1021impl CAEIMW {
1022 #[allow(missing_docs)]
1023 #[doc(hidden)]
1024 #[inline]
1025 pub fn _bits(&self) -> bool {
1026 match *self {
1027 CAEIMW::EN => true,
1028 CAEIMW::DIS => false,
1029 }
1030 }
1031}
1032#[doc = r" Proxy"]
1033pub struct _CAEIMW<'a> {
1034 w: &'a mut W,
1035}
1036impl<'a> _CAEIMW<'a> {
1037 #[doc = r" Writes `variant` to the field"]
1038 #[inline]
1039 pub fn variant(self, variant: CAEIMW) -> &'a mut W {
1040 {
1041 self.bit(variant._bits())
1042 }
1043 }
1044 #[doc = "Enable Interrupt"]
1045 #[inline]
1046 pub fn en(self) -> &'a mut W {
1047 self.variant(CAEIMW::EN)
1048 }
1049 #[doc = "Disable Interrupt"]
1050 #[inline]
1051 pub fn dis(self) -> &'a mut W {
1052 self.variant(CAEIMW::DIS)
1053 }
1054 #[doc = r" Sets the field bit"]
1055 pub fn set_bit(self) -> &'a mut W {
1056 self.bit(true)
1057 }
1058 #[doc = r" Clears the field bit"]
1059 pub fn clear_bit(self) -> &'a mut W {
1060 self.bit(false)
1061 }
1062 #[doc = r" Writes raw bits to the field"]
1063 #[inline]
1064 pub fn bit(self, value: bool) -> &'a mut W {
1065 const MASK: bool = true;
1066 const OFFSET: u8 = 2;
1067 self.w.bits &= !((MASK as u32) << OFFSET);
1068 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1069 self.w
1070 }
1071}
1072#[doc = "Values that can be written to the field `CAMIM`"]
1073#[derive(Clone, Copy, Debug, PartialEq)]
1074pub enum CAMIMW {
1075 #[doc = "Enable Interrupt"]
1076 EN,
1077 #[doc = "Disable Interrupt"]
1078 DIS,
1079}
1080impl CAMIMW {
1081 #[allow(missing_docs)]
1082 #[doc(hidden)]
1083 #[inline]
1084 pub fn _bits(&self) -> bool {
1085 match *self {
1086 CAMIMW::EN => true,
1087 CAMIMW::DIS => false,
1088 }
1089 }
1090}
1091#[doc = r" Proxy"]
1092pub struct _CAMIMW<'a> {
1093 w: &'a mut W,
1094}
1095impl<'a> _CAMIMW<'a> {
1096 #[doc = r" Writes `variant` to the field"]
1097 #[inline]
1098 pub fn variant(self, variant: CAMIMW) -> &'a mut W {
1099 {
1100 self.bit(variant._bits())
1101 }
1102 }
1103 #[doc = "Enable Interrupt"]
1104 #[inline]
1105 pub fn en(self) -> &'a mut W {
1106 self.variant(CAMIMW::EN)
1107 }
1108 #[doc = "Disable Interrupt"]
1109 #[inline]
1110 pub fn dis(self) -> &'a mut W {
1111 self.variant(CAMIMW::DIS)
1112 }
1113 #[doc = r" Sets the field bit"]
1114 pub fn set_bit(self) -> &'a mut W {
1115 self.bit(true)
1116 }
1117 #[doc = r" Clears the field bit"]
1118 pub fn clear_bit(self) -> &'a mut W {
1119 self.bit(false)
1120 }
1121 #[doc = r" Writes raw bits to the field"]
1122 #[inline]
1123 pub fn bit(self, value: bool) -> &'a mut W {
1124 const MASK: bool = true;
1125 const OFFSET: u8 = 1;
1126 self.w.bits &= !((MASK as u32) << OFFSET);
1127 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1128 self.w
1129 }
1130}
1131#[doc = "Values that can be written to the field `TATOIM`"]
1132#[derive(Clone, Copy, Debug, PartialEq)]
1133pub enum TATOIMW {
1134 #[doc = "Enable Interrupt"]
1135 EN,
1136 #[doc = "Disable Interrupt"]
1137 DIS,
1138}
1139impl TATOIMW {
1140 #[allow(missing_docs)]
1141 #[doc(hidden)]
1142 #[inline]
1143 pub fn _bits(&self) -> bool {
1144 match *self {
1145 TATOIMW::EN => true,
1146 TATOIMW::DIS => false,
1147 }
1148 }
1149}
1150#[doc = r" Proxy"]
1151pub struct _TATOIMW<'a> {
1152 w: &'a mut W,
1153}
1154impl<'a> _TATOIMW<'a> {
1155 #[doc = r" Writes `variant` to the field"]
1156 #[inline]
1157 pub fn variant(self, variant: TATOIMW) -> &'a mut W {
1158 {
1159 self.bit(variant._bits())
1160 }
1161 }
1162 #[doc = "Enable Interrupt"]
1163 #[inline]
1164 pub fn en(self) -> &'a mut W {
1165 self.variant(TATOIMW::EN)
1166 }
1167 #[doc = "Disable Interrupt"]
1168 #[inline]
1169 pub fn dis(self) -> &'a mut W {
1170 self.variant(TATOIMW::DIS)
1171 }
1172 #[doc = r" Sets the field bit"]
1173 pub fn set_bit(self) -> &'a mut W {
1174 self.bit(true)
1175 }
1176 #[doc = r" Clears the field bit"]
1177 pub fn clear_bit(self) -> &'a mut W {
1178 self.bit(false)
1179 }
1180 #[doc = r" Writes raw bits to the field"]
1181 #[inline]
1182 pub fn bit(self, value: bool) -> &'a mut W {
1183 const MASK: bool = true;
1184 const OFFSET: u8 = 0;
1185 self.w.bits &= !((MASK as u32) << OFFSET);
1186 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1187 self.w
1188 }
1189}
1190impl R {
1191 #[doc = r" Value of the register as raw bits"]
1192 #[inline]
1193 pub fn bits(&self) -> u32 {
1194 self.bits
1195 }
1196 #[doc = "Bits 14:31 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1197 #[inline]
1198 pub fn reserved14(&self) -> RESERVED14R {
1199 let bits = {
1200 const MASK: u32 = 262143;
1201 const OFFSET: u8 = 14;
1202 ((self.bits >> OFFSET) & MASK as u32) as u32
1203 };
1204 RESERVED14R { bits }
1205 }
1206 #[doc = "Bit 13 - Enabling this bit will make the RIS.DMABRIS interrupt propagate to MIS.DMABMIS"]
1207 #[inline]
1208 pub fn dmabim(&self) -> DMABIMR {
1209 DMABIMR::_from({
1210 const MASK: bool = true;
1211 const OFFSET: u8 = 13;
1212 ((self.bits >> OFFSET) & MASK as u32) != 0
1213 })
1214 }
1215 #[doc = "Bit 12 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1216 #[inline]
1217 pub fn reserved12(&self) -> RESERVED12R {
1218 let bits = {
1219 const MASK: bool = true;
1220 const OFFSET: u8 = 12;
1221 ((self.bits >> OFFSET) & MASK as u32) != 0
1222 };
1223 RESERVED12R { bits }
1224 }
1225 #[doc = "Bit 11 - Enabling this bit will make the RIS.TBMRIS interrupt propagate to MIS.TBMMIS"]
1226 #[inline]
1227 pub fn tbmim(&self) -> TBMIMR {
1228 TBMIMR::_from({
1229 const MASK: bool = true;
1230 const OFFSET: u8 = 11;
1231 ((self.bits >> OFFSET) & MASK as u32) != 0
1232 })
1233 }
1234 #[doc = "Bit 10 - Enabling this bit will make the RIS.CBERIS interrupt propagate to MIS.CBEMIS"]
1235 #[inline]
1236 pub fn cbeim(&self) -> CBEIMR {
1237 CBEIMR::_from({
1238 const MASK: bool = true;
1239 const OFFSET: u8 = 10;
1240 ((self.bits >> OFFSET) & MASK as u32) != 0
1241 })
1242 }
1243 #[doc = "Bit 9 - Enabling this bit will make the RIS.CBMRIS interrupt propagate to MIS.CBMMIS"]
1244 #[inline]
1245 pub fn cbmim(&self) -> CBMIMR {
1246 CBMIMR::_from({
1247 const MASK: bool = true;
1248 const OFFSET: u8 = 9;
1249 ((self.bits >> OFFSET) & MASK as u32) != 0
1250 })
1251 }
1252 #[doc = "Bit 8 - Enabling this bit will make the RIS.TBTORIS interrupt propagate to MIS.TBTOMIS"]
1253 #[inline]
1254 pub fn tbtoim(&self) -> TBTOIMR {
1255 TBTOIMR::_from({
1256 const MASK: bool = true;
1257 const OFFSET: u8 = 8;
1258 ((self.bits >> OFFSET) & MASK as u32) != 0
1259 })
1260 }
1261 #[doc = "Bits 6:7 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1262 #[inline]
1263 pub fn reserved6(&self) -> RESERVED6R {
1264 let bits = {
1265 const MASK: u8 = 3;
1266 const OFFSET: u8 = 6;
1267 ((self.bits >> OFFSET) & MASK as u32) as u8
1268 };
1269 RESERVED6R { bits }
1270 }
1271 #[doc = "Bit 5 - Enabling this bit will make the RIS.DMAARIS interrupt propagate to MIS.DMAAMIS"]
1272 #[inline]
1273 pub fn dmaaim(&self) -> DMAAIMR {
1274 DMAAIMR::_from({
1275 const MASK: bool = true;
1276 const OFFSET: u8 = 5;
1277 ((self.bits >> OFFSET) & MASK as u32) != 0
1278 })
1279 }
1280 #[doc = "Bit 4 - Enabling this bit will make the RIS.TAMRIS interrupt propagate to MIS.TAMMIS"]
1281 #[inline]
1282 pub fn tamim(&self) -> TAMIMR {
1283 TAMIMR::_from({
1284 const MASK: bool = true;
1285 const OFFSET: u8 = 4;
1286 ((self.bits >> OFFSET) & MASK as u32) != 0
1287 })
1288 }
1289 #[doc = "Bit 3 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1290 #[inline]
1291 pub fn reserved3(&self) -> RESERVED3R {
1292 let bits = {
1293 const MASK: bool = true;
1294 const OFFSET: u8 = 3;
1295 ((self.bits >> OFFSET) & MASK as u32) != 0
1296 };
1297 RESERVED3R { bits }
1298 }
1299 #[doc = "Bit 2 - Enabling this bit will make the RIS.CAERIS interrupt propagate to MIS.CAEMIS"]
1300 #[inline]
1301 pub fn caeim(&self) -> CAEIMR {
1302 CAEIMR::_from({
1303 const MASK: bool = true;
1304 const OFFSET: u8 = 2;
1305 ((self.bits >> OFFSET) & MASK as u32) != 0
1306 })
1307 }
1308 #[doc = "Bit 1 - Enabling this bit will make the RIS.CAMRIS interrupt propagate to MIS.CAMMIS"]
1309 #[inline]
1310 pub fn camim(&self) -> CAMIMR {
1311 CAMIMR::_from({
1312 const MASK: bool = true;
1313 const OFFSET: u8 = 1;
1314 ((self.bits >> OFFSET) & MASK as u32) != 0
1315 })
1316 }
1317 #[doc = "Bit 0 - Enabling this bit will make the RIS.TATORIS interrupt propagate to MIS.TATOMIS"]
1318 #[inline]
1319 pub fn tatoim(&self) -> TATOIMR {
1320 TATOIMR::_from({
1321 const MASK: bool = true;
1322 const OFFSET: u8 = 0;
1323 ((self.bits >> OFFSET) & MASK as u32) != 0
1324 })
1325 }
1326}
1327impl W {
1328 #[doc = r" Reset value of the register"]
1329 #[inline]
1330 pub fn reset_value() -> W {
1331 W { bits: 0 }
1332 }
1333 #[doc = r" Writes raw bits to the register"]
1334 #[inline]
1335 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1336 self.bits = bits;
1337 self
1338 }
1339 #[doc = "Bit 13 - Enabling this bit will make the RIS.DMABRIS interrupt propagate to MIS.DMABMIS"]
1340 #[inline]
1341 pub fn dmabim(&mut self) -> _DMABIMW {
1342 _DMABIMW { w: self }
1343 }
1344 #[doc = "Bit 11 - Enabling this bit will make the RIS.TBMRIS interrupt propagate to MIS.TBMMIS"]
1345 #[inline]
1346 pub fn tbmim(&mut self) -> _TBMIMW {
1347 _TBMIMW { w: self }
1348 }
1349 #[doc = "Bit 10 - Enabling this bit will make the RIS.CBERIS interrupt propagate to MIS.CBEMIS"]
1350 #[inline]
1351 pub fn cbeim(&mut self) -> _CBEIMW {
1352 _CBEIMW { w: self }
1353 }
1354 #[doc = "Bit 9 - Enabling this bit will make the RIS.CBMRIS interrupt propagate to MIS.CBMMIS"]
1355 #[inline]
1356 pub fn cbmim(&mut self) -> _CBMIMW {
1357 _CBMIMW { w: self }
1358 }
1359 #[doc = "Bit 8 - Enabling this bit will make the RIS.TBTORIS interrupt propagate to MIS.TBTOMIS"]
1360 #[inline]
1361 pub fn tbtoim(&mut self) -> _TBTOIMW {
1362 _TBTOIMW { w: self }
1363 }
1364 #[doc = "Bit 5 - Enabling this bit will make the RIS.DMAARIS interrupt propagate to MIS.DMAAMIS"]
1365 #[inline]
1366 pub fn dmaaim(&mut self) -> _DMAAIMW {
1367 _DMAAIMW { w: self }
1368 }
1369 #[doc = "Bit 4 - Enabling this bit will make the RIS.TAMRIS interrupt propagate to MIS.TAMMIS"]
1370 #[inline]
1371 pub fn tamim(&mut self) -> _TAMIMW {
1372 _TAMIMW { w: self }
1373 }
1374 #[doc = "Bit 3 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
1375 #[inline]
1376 pub fn reserved3(&mut self) -> _RESERVED3W {
1377 _RESERVED3W { w: self }
1378 }
1379 #[doc = "Bit 2 - Enabling this bit will make the RIS.CAERIS interrupt propagate to MIS.CAEMIS"]
1380 #[inline]
1381 pub fn caeim(&mut self) -> _CAEIMW {
1382 _CAEIMW { w: self }
1383 }
1384 #[doc = "Bit 1 - Enabling this bit will make the RIS.CAMRIS interrupt propagate to MIS.CAMMIS"]
1385 #[inline]
1386 pub fn camim(&mut self) -> _CAMIMW {
1387 _CAMIMW { w: self }
1388 }
1389 #[doc = "Bit 0 - Enabling this bit will make the RIS.TATORIS interrupt propagate to MIS.TATOMIS"]
1390 #[inline]
1391 pub fn tatoim(&mut self) -> _TATOIMW {
1392 _TATOIMW { w: self }
1393 }
1394}