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::MCR {
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 = "Possible values of the field `MR0I`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum MR0IR {
48 #[doc = "Enabled"]
49 ENABLED,
50 #[doc = "Disabled"]
51 DISABLED,
52}
53impl MR0IR {
54 #[doc = r" Returns `true` if the bit is clear (0)"]
55 #[inline]
56 pub fn bit_is_clear(&self) -> bool {
57 !self.bit()
58 }
59 #[doc = r" Returns `true` if the bit is set (1)"]
60 #[inline]
61 pub fn bit_is_set(&self) -> bool {
62 self.bit()
63 }
64 #[doc = r" Value of the field as raw bits"]
65 #[inline]
66 pub fn bit(&self) -> bool {
67 match *self {
68 MR0IR::ENABLED => true,
69 MR0IR::DISABLED => false,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> MR0IR {
76 match value {
77 true => MR0IR::ENABLED,
78 false => MR0IR::DISABLED,
79 }
80 }
81 #[doc = "Checks if the value of the field is `ENABLED`"]
82 #[inline]
83 pub fn is_enabled(&self) -> bool {
84 *self == MR0IR::ENABLED
85 }
86 #[doc = "Checks if the value of the field is `DISABLED`"]
87 #[inline]
88 pub fn is_disabled(&self) -> bool {
89 *self == MR0IR::DISABLED
90 }
91}
92#[doc = "Possible values of the field `MR0R`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum MR0RR {
95 #[doc = "Enabled"]
96 ENABLED,
97 #[doc = "Disabled"]
98 DISABLED,
99}
100impl MR0RR {
101 #[doc = r" Returns `true` if the bit is clear (0)"]
102 #[inline]
103 pub fn bit_is_clear(&self) -> bool {
104 !self.bit()
105 }
106 #[doc = r" Returns `true` if the bit is set (1)"]
107 #[inline]
108 pub fn bit_is_set(&self) -> bool {
109 self.bit()
110 }
111 #[doc = r" Value of the field as raw bits"]
112 #[inline]
113 pub fn bit(&self) -> bool {
114 match *self {
115 MR0RR::ENABLED => true,
116 MR0RR::DISABLED => false,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> MR0RR {
123 match value {
124 true => MR0RR::ENABLED,
125 false => MR0RR::DISABLED,
126 }
127 }
128 #[doc = "Checks if the value of the field is `ENABLED`"]
129 #[inline]
130 pub fn is_enabled(&self) -> bool {
131 *self == MR0RR::ENABLED
132 }
133 #[doc = "Checks if the value of the field is `DISABLED`"]
134 #[inline]
135 pub fn is_disabled(&self) -> bool {
136 *self == MR0RR::DISABLED
137 }
138}
139#[doc = "Possible values of the field `MR0S`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum MR0SR {
142 #[doc = "Enabled"]
143 ENABLED,
144 #[doc = "Disabled"]
145 DISABLED,
146}
147impl MR0SR {
148 #[doc = r" Returns `true` if the bit is clear (0)"]
149 #[inline]
150 pub fn bit_is_clear(&self) -> bool {
151 !self.bit()
152 }
153 #[doc = r" Returns `true` if the bit is set (1)"]
154 #[inline]
155 pub fn bit_is_set(&self) -> bool {
156 self.bit()
157 }
158 #[doc = r" Value of the field as raw bits"]
159 #[inline]
160 pub fn bit(&self) -> bool {
161 match *self {
162 MR0SR::ENABLED => true,
163 MR0SR::DISABLED => false,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> MR0SR {
170 match value {
171 true => MR0SR::ENABLED,
172 false => MR0SR::DISABLED,
173 }
174 }
175 #[doc = "Checks if the value of the field is `ENABLED`"]
176 #[inline]
177 pub fn is_enabled(&self) -> bool {
178 *self == MR0SR::ENABLED
179 }
180 #[doc = "Checks if the value of the field is `DISABLED`"]
181 #[inline]
182 pub fn is_disabled(&self) -> bool {
183 *self == MR0SR::DISABLED
184 }
185}
186#[doc = "Possible values of the field `MR1I`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum MR1IR {
189 #[doc = "Enabled"]
190 ENABLED,
191 #[doc = "Disabled"]
192 DISABLED,
193}
194impl MR1IR {
195 #[doc = r" Returns `true` if the bit is clear (0)"]
196 #[inline]
197 pub fn bit_is_clear(&self) -> bool {
198 !self.bit()
199 }
200 #[doc = r" Returns `true` if the bit is set (1)"]
201 #[inline]
202 pub fn bit_is_set(&self) -> bool {
203 self.bit()
204 }
205 #[doc = r" Value of the field as raw bits"]
206 #[inline]
207 pub fn bit(&self) -> bool {
208 match *self {
209 MR1IR::ENABLED => true,
210 MR1IR::DISABLED => false,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> MR1IR {
217 match value {
218 true => MR1IR::ENABLED,
219 false => MR1IR::DISABLED,
220 }
221 }
222 #[doc = "Checks if the value of the field is `ENABLED`"]
223 #[inline]
224 pub fn is_enabled(&self) -> bool {
225 *self == MR1IR::ENABLED
226 }
227 #[doc = "Checks if the value of the field is `DISABLED`"]
228 #[inline]
229 pub fn is_disabled(&self) -> bool {
230 *self == MR1IR::DISABLED
231 }
232}
233#[doc = "Possible values of the field `MR1R`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum MR1RR {
236 #[doc = "Enabled"]
237 ENABLED,
238 #[doc = "Disabled"]
239 DISABLED,
240}
241impl MR1RR {
242 #[doc = r" Returns `true` if the bit is clear (0)"]
243 #[inline]
244 pub fn bit_is_clear(&self) -> bool {
245 !self.bit()
246 }
247 #[doc = r" Returns `true` if the bit is set (1)"]
248 #[inline]
249 pub fn bit_is_set(&self) -> bool {
250 self.bit()
251 }
252 #[doc = r" Value of the field as raw bits"]
253 #[inline]
254 pub fn bit(&self) -> bool {
255 match *self {
256 MR1RR::ENABLED => true,
257 MR1RR::DISABLED => false,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> MR1RR {
264 match value {
265 true => MR1RR::ENABLED,
266 false => MR1RR::DISABLED,
267 }
268 }
269 #[doc = "Checks if the value of the field is `ENABLED`"]
270 #[inline]
271 pub fn is_enabled(&self) -> bool {
272 *self == MR1RR::ENABLED
273 }
274 #[doc = "Checks if the value of the field is `DISABLED`"]
275 #[inline]
276 pub fn is_disabled(&self) -> bool {
277 *self == MR1RR::DISABLED
278 }
279}
280#[doc = "Possible values of the field `MR1S`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum MR1SR {
283 #[doc = "Enabled"]
284 ENABLED,
285 #[doc = "Disabled"]
286 DISABLED,
287}
288impl MR1SR {
289 #[doc = r" Returns `true` if the bit is clear (0)"]
290 #[inline]
291 pub fn bit_is_clear(&self) -> bool {
292 !self.bit()
293 }
294 #[doc = r" Returns `true` if the bit is set (1)"]
295 #[inline]
296 pub fn bit_is_set(&self) -> bool {
297 self.bit()
298 }
299 #[doc = r" Value of the field as raw bits"]
300 #[inline]
301 pub fn bit(&self) -> bool {
302 match *self {
303 MR1SR::ENABLED => true,
304 MR1SR::DISABLED => false,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> MR1SR {
311 match value {
312 true => MR1SR::ENABLED,
313 false => MR1SR::DISABLED,
314 }
315 }
316 #[doc = "Checks if the value of the field is `ENABLED`"]
317 #[inline]
318 pub fn is_enabled(&self) -> bool {
319 *self == MR1SR::ENABLED
320 }
321 #[doc = "Checks if the value of the field is `DISABLED`"]
322 #[inline]
323 pub fn is_disabled(&self) -> bool {
324 *self == MR1SR::DISABLED
325 }
326}
327#[doc = "Possible values of the field `MR2I`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum MR2IR {
330 #[doc = "Enabled"]
331 ENABLED,
332 #[doc = "Disabled"]
333 DISABLED,
334}
335impl MR2IR {
336 #[doc = r" Returns `true` if the bit is clear (0)"]
337 #[inline]
338 pub fn bit_is_clear(&self) -> bool {
339 !self.bit()
340 }
341 #[doc = r" Returns `true` if the bit is set (1)"]
342 #[inline]
343 pub fn bit_is_set(&self) -> bool {
344 self.bit()
345 }
346 #[doc = r" Value of the field as raw bits"]
347 #[inline]
348 pub fn bit(&self) -> bool {
349 match *self {
350 MR2IR::ENABLED => true,
351 MR2IR::DISABLED => false,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> MR2IR {
358 match value {
359 true => MR2IR::ENABLED,
360 false => MR2IR::DISABLED,
361 }
362 }
363 #[doc = "Checks if the value of the field is `ENABLED`"]
364 #[inline]
365 pub fn is_enabled(&self) -> bool {
366 *self == MR2IR::ENABLED
367 }
368 #[doc = "Checks if the value of the field is `DISABLED`"]
369 #[inline]
370 pub fn is_disabled(&self) -> bool {
371 *self == MR2IR::DISABLED
372 }
373}
374#[doc = "Possible values of the field `MR2R`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum MR2RR {
377 #[doc = "Enabled"]
378 ENABLED,
379 #[doc = "Disabled"]
380 DISABLED,
381}
382impl MR2RR {
383 #[doc = r" Returns `true` if the bit is clear (0)"]
384 #[inline]
385 pub fn bit_is_clear(&self) -> bool {
386 !self.bit()
387 }
388 #[doc = r" Returns `true` if the bit is set (1)"]
389 #[inline]
390 pub fn bit_is_set(&self) -> bool {
391 self.bit()
392 }
393 #[doc = r" Value of the field as raw bits"]
394 #[inline]
395 pub fn bit(&self) -> bool {
396 match *self {
397 MR2RR::ENABLED => true,
398 MR2RR::DISABLED => false,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> MR2RR {
405 match value {
406 true => MR2RR::ENABLED,
407 false => MR2RR::DISABLED,
408 }
409 }
410 #[doc = "Checks if the value of the field is `ENABLED`"]
411 #[inline]
412 pub fn is_enabled(&self) -> bool {
413 *self == MR2RR::ENABLED
414 }
415 #[doc = "Checks if the value of the field is `DISABLED`"]
416 #[inline]
417 pub fn is_disabled(&self) -> bool {
418 *self == MR2RR::DISABLED
419 }
420}
421#[doc = "Possible values of the field `MR2S`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum MR2SR {
424 #[doc = "Enabled"]
425 ENABLED,
426 #[doc = "Disabled"]
427 DISABLED,
428}
429impl MR2SR {
430 #[doc = r" Returns `true` if the bit is clear (0)"]
431 #[inline]
432 pub fn bit_is_clear(&self) -> bool {
433 !self.bit()
434 }
435 #[doc = r" Returns `true` if the bit is set (1)"]
436 #[inline]
437 pub fn bit_is_set(&self) -> bool {
438 self.bit()
439 }
440 #[doc = r" Value of the field as raw bits"]
441 #[inline]
442 pub fn bit(&self) -> bool {
443 match *self {
444 MR2SR::ENABLED => true,
445 MR2SR::DISABLED => false,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> MR2SR {
452 match value {
453 true => MR2SR::ENABLED,
454 false => MR2SR::DISABLED,
455 }
456 }
457 #[doc = "Checks if the value of the field is `ENABLED`"]
458 #[inline]
459 pub fn is_enabled(&self) -> bool {
460 *self == MR2SR::ENABLED
461 }
462 #[doc = "Checks if the value of the field is `DISABLED`"]
463 #[inline]
464 pub fn is_disabled(&self) -> bool {
465 *self == MR2SR::DISABLED
466 }
467}
468#[doc = "Possible values of the field `MR3I`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum MR3IR {
471 #[doc = "Enabled"]
472 ENABLED,
473 #[doc = "Disabled"]
474 DISABLED,
475}
476impl MR3IR {
477 #[doc = r" Returns `true` if the bit is clear (0)"]
478 #[inline]
479 pub fn bit_is_clear(&self) -> bool {
480 !self.bit()
481 }
482 #[doc = r" Returns `true` if the bit is set (1)"]
483 #[inline]
484 pub fn bit_is_set(&self) -> bool {
485 self.bit()
486 }
487 #[doc = r" Value of the field as raw bits"]
488 #[inline]
489 pub fn bit(&self) -> bool {
490 match *self {
491 MR3IR::ENABLED => true,
492 MR3IR::DISABLED => false,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> MR3IR {
499 match value {
500 true => MR3IR::ENABLED,
501 false => MR3IR::DISABLED,
502 }
503 }
504 #[doc = "Checks if the value of the field is `ENABLED`"]
505 #[inline]
506 pub fn is_enabled(&self) -> bool {
507 *self == MR3IR::ENABLED
508 }
509 #[doc = "Checks if the value of the field is `DISABLED`"]
510 #[inline]
511 pub fn is_disabled(&self) -> bool {
512 *self == MR3IR::DISABLED
513 }
514}
515#[doc = "Possible values of the field `MR3R`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum MR3RR {
518 #[doc = "Enabled"]
519 ENABLED,
520 #[doc = "Disabled"]
521 DISABLED,
522}
523impl MR3RR {
524 #[doc = r" Returns `true` if the bit is clear (0)"]
525 #[inline]
526 pub fn bit_is_clear(&self) -> bool {
527 !self.bit()
528 }
529 #[doc = r" Returns `true` if the bit is set (1)"]
530 #[inline]
531 pub fn bit_is_set(&self) -> bool {
532 self.bit()
533 }
534 #[doc = r" Value of the field as raw bits"]
535 #[inline]
536 pub fn bit(&self) -> bool {
537 match *self {
538 MR3RR::ENABLED => true,
539 MR3RR::DISABLED => false,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> MR3RR {
546 match value {
547 true => MR3RR::ENABLED,
548 false => MR3RR::DISABLED,
549 }
550 }
551 #[doc = "Checks if the value of the field is `ENABLED`"]
552 #[inline]
553 pub fn is_enabled(&self) -> bool {
554 *self == MR3RR::ENABLED
555 }
556 #[doc = "Checks if the value of the field is `DISABLED`"]
557 #[inline]
558 pub fn is_disabled(&self) -> bool {
559 *self == MR3RR::DISABLED
560 }
561}
562#[doc = "Possible values of the field `MR3S`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum MR3SR {
565 #[doc = "Enabled"]
566 ENABLED,
567 #[doc = "Disabled"]
568 DISABLED,
569}
570impl MR3SR {
571 #[doc = r" Returns `true` if the bit is clear (0)"]
572 #[inline]
573 pub fn bit_is_clear(&self) -> bool {
574 !self.bit()
575 }
576 #[doc = r" Returns `true` if the bit is set (1)"]
577 #[inline]
578 pub fn bit_is_set(&self) -> bool {
579 self.bit()
580 }
581 #[doc = r" Value of the field as raw bits"]
582 #[inline]
583 pub fn bit(&self) -> bool {
584 match *self {
585 MR3SR::ENABLED => true,
586 MR3SR::DISABLED => false,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> MR3SR {
593 match value {
594 true => MR3SR::ENABLED,
595 false => MR3SR::DISABLED,
596 }
597 }
598 #[doc = "Checks if the value of the field is `ENABLED`"]
599 #[inline]
600 pub fn is_enabled(&self) -> bool {
601 *self == MR3SR::ENABLED
602 }
603 #[doc = "Checks if the value of the field is `DISABLED`"]
604 #[inline]
605 pub fn is_disabled(&self) -> bool {
606 *self == MR3SR::DISABLED
607 }
608}
609#[doc = "Values that can be written to the field `MR0I`"]
610pub enum MR0IW {
611 #[doc = "Enabled"]
612 ENABLED,
613 #[doc = "Disabled"]
614 DISABLED,
615}
616impl MR0IW {
617 #[allow(missing_docs)]
618 #[doc(hidden)]
619 #[inline]
620 pub fn _bits(&self) -> bool {
621 match *self {
622 MR0IW::ENABLED => true,
623 MR0IW::DISABLED => false,
624 }
625 }
626}
627#[doc = r" Proxy"]
628pub struct _MR0IW<'a> {
629 w: &'a mut W,
630}
631impl<'a> _MR0IW<'a> {
632 #[doc = r" Writes `variant` to the field"]
633 #[inline]
634 pub fn variant(self, variant: MR0IW) -> &'a mut W {
635 {
636 self.bit(variant._bits())
637 }
638 }
639 #[doc = "Enabled"]
640 #[inline]
641 pub fn enabled(self) -> &'a mut W {
642 self.variant(MR0IW::ENABLED)
643 }
644 #[doc = "Disabled"]
645 #[inline]
646 pub fn disabled(self) -> &'a mut W {
647 self.variant(MR0IW::DISABLED)
648 }
649 #[doc = r" Sets the field bit"]
650 pub fn set_bit(self) -> &'a mut W {
651 self.bit(true)
652 }
653 #[doc = r" Clears the field bit"]
654 pub fn clear_bit(self) -> &'a mut W {
655 self.bit(false)
656 }
657 #[doc = r" Writes raw bits to the field"]
658 #[inline]
659 pub fn bit(self, value: bool) -> &'a mut W {
660 const MASK: bool = true;
661 const OFFSET: u8 = 0;
662 self.w.bits &= !((MASK as u32) << OFFSET);
663 self.w.bits |= ((value & MASK) as u32) << OFFSET;
664 self.w
665 }
666}
667#[doc = "Values that can be written to the field `MR0R`"]
668pub enum MR0RW {
669 #[doc = "Enabled"]
670 ENABLED,
671 #[doc = "Disabled"]
672 DISABLED,
673}
674impl MR0RW {
675 #[allow(missing_docs)]
676 #[doc(hidden)]
677 #[inline]
678 pub fn _bits(&self) -> bool {
679 match *self {
680 MR0RW::ENABLED => true,
681 MR0RW::DISABLED => false,
682 }
683 }
684}
685#[doc = r" Proxy"]
686pub struct _MR0RW<'a> {
687 w: &'a mut W,
688}
689impl<'a> _MR0RW<'a> {
690 #[doc = r" Writes `variant` to the field"]
691 #[inline]
692 pub fn variant(self, variant: MR0RW) -> &'a mut W {
693 {
694 self.bit(variant._bits())
695 }
696 }
697 #[doc = "Enabled"]
698 #[inline]
699 pub fn enabled(self) -> &'a mut W {
700 self.variant(MR0RW::ENABLED)
701 }
702 #[doc = "Disabled"]
703 #[inline]
704 pub fn disabled(self) -> &'a mut W {
705 self.variant(MR0RW::DISABLED)
706 }
707 #[doc = r" Sets the field bit"]
708 pub fn set_bit(self) -> &'a mut W {
709 self.bit(true)
710 }
711 #[doc = r" Clears the field bit"]
712 pub fn clear_bit(self) -> &'a mut W {
713 self.bit(false)
714 }
715 #[doc = r" Writes raw bits to the field"]
716 #[inline]
717 pub fn bit(self, value: bool) -> &'a mut W {
718 const MASK: bool = true;
719 const OFFSET: u8 = 1;
720 self.w.bits &= !((MASK as u32) << OFFSET);
721 self.w.bits |= ((value & MASK) as u32) << OFFSET;
722 self.w
723 }
724}
725#[doc = "Values that can be written to the field `MR0S`"]
726pub enum MR0SW {
727 #[doc = "Enabled"]
728 ENABLED,
729 #[doc = "Disabled"]
730 DISABLED,
731}
732impl MR0SW {
733 #[allow(missing_docs)]
734 #[doc(hidden)]
735 #[inline]
736 pub fn _bits(&self) -> bool {
737 match *self {
738 MR0SW::ENABLED => true,
739 MR0SW::DISABLED => false,
740 }
741 }
742}
743#[doc = r" Proxy"]
744pub struct _MR0SW<'a> {
745 w: &'a mut W,
746}
747impl<'a> _MR0SW<'a> {
748 #[doc = r" Writes `variant` to the field"]
749 #[inline]
750 pub fn variant(self, variant: MR0SW) -> &'a mut W {
751 {
752 self.bit(variant._bits())
753 }
754 }
755 #[doc = "Enabled"]
756 #[inline]
757 pub fn enabled(self) -> &'a mut W {
758 self.variant(MR0SW::ENABLED)
759 }
760 #[doc = "Disabled"]
761 #[inline]
762 pub fn disabled(self) -> &'a mut W {
763 self.variant(MR0SW::DISABLED)
764 }
765 #[doc = r" Sets the field bit"]
766 pub fn set_bit(self) -> &'a mut W {
767 self.bit(true)
768 }
769 #[doc = r" Clears the field bit"]
770 pub fn clear_bit(self) -> &'a mut W {
771 self.bit(false)
772 }
773 #[doc = r" Writes raw bits to the field"]
774 #[inline]
775 pub fn bit(self, value: bool) -> &'a mut W {
776 const MASK: bool = true;
777 const OFFSET: u8 = 2;
778 self.w.bits &= !((MASK as u32) << OFFSET);
779 self.w.bits |= ((value & MASK) as u32) << OFFSET;
780 self.w
781 }
782}
783#[doc = "Values that can be written to the field `MR1I`"]
784pub enum MR1IW {
785 #[doc = "Enabled"]
786 ENABLED,
787 #[doc = "Disabled"]
788 DISABLED,
789}
790impl MR1IW {
791 #[allow(missing_docs)]
792 #[doc(hidden)]
793 #[inline]
794 pub fn _bits(&self) -> bool {
795 match *self {
796 MR1IW::ENABLED => true,
797 MR1IW::DISABLED => false,
798 }
799 }
800}
801#[doc = r" Proxy"]
802pub struct _MR1IW<'a> {
803 w: &'a mut W,
804}
805impl<'a> _MR1IW<'a> {
806 #[doc = r" Writes `variant` to the field"]
807 #[inline]
808 pub fn variant(self, variant: MR1IW) -> &'a mut W {
809 {
810 self.bit(variant._bits())
811 }
812 }
813 #[doc = "Enabled"]
814 #[inline]
815 pub fn enabled(self) -> &'a mut W {
816 self.variant(MR1IW::ENABLED)
817 }
818 #[doc = "Disabled"]
819 #[inline]
820 pub fn disabled(self) -> &'a mut W {
821 self.variant(MR1IW::DISABLED)
822 }
823 #[doc = r" Sets the field bit"]
824 pub fn set_bit(self) -> &'a mut W {
825 self.bit(true)
826 }
827 #[doc = r" Clears the field bit"]
828 pub fn clear_bit(self) -> &'a mut W {
829 self.bit(false)
830 }
831 #[doc = r" Writes raw bits to the field"]
832 #[inline]
833 pub fn bit(self, value: bool) -> &'a mut W {
834 const MASK: bool = true;
835 const OFFSET: u8 = 3;
836 self.w.bits &= !((MASK as u32) << OFFSET);
837 self.w.bits |= ((value & MASK) as u32) << OFFSET;
838 self.w
839 }
840}
841#[doc = "Values that can be written to the field `MR1R`"]
842pub enum MR1RW {
843 #[doc = "Enabled"]
844 ENABLED,
845 #[doc = "Disabled"]
846 DISABLED,
847}
848impl MR1RW {
849 #[allow(missing_docs)]
850 #[doc(hidden)]
851 #[inline]
852 pub fn _bits(&self) -> bool {
853 match *self {
854 MR1RW::ENABLED => true,
855 MR1RW::DISABLED => false,
856 }
857 }
858}
859#[doc = r" Proxy"]
860pub struct _MR1RW<'a> {
861 w: &'a mut W,
862}
863impl<'a> _MR1RW<'a> {
864 #[doc = r" Writes `variant` to the field"]
865 #[inline]
866 pub fn variant(self, variant: MR1RW) -> &'a mut W {
867 {
868 self.bit(variant._bits())
869 }
870 }
871 #[doc = "Enabled"]
872 #[inline]
873 pub fn enabled(self) -> &'a mut W {
874 self.variant(MR1RW::ENABLED)
875 }
876 #[doc = "Disabled"]
877 #[inline]
878 pub fn disabled(self) -> &'a mut W {
879 self.variant(MR1RW::DISABLED)
880 }
881 #[doc = r" Sets the field bit"]
882 pub fn set_bit(self) -> &'a mut W {
883 self.bit(true)
884 }
885 #[doc = r" Clears the field bit"]
886 pub fn clear_bit(self) -> &'a mut W {
887 self.bit(false)
888 }
889 #[doc = r" Writes raw bits to the field"]
890 #[inline]
891 pub fn bit(self, value: bool) -> &'a mut W {
892 const MASK: bool = true;
893 const OFFSET: u8 = 4;
894 self.w.bits &= !((MASK as u32) << OFFSET);
895 self.w.bits |= ((value & MASK) as u32) << OFFSET;
896 self.w
897 }
898}
899#[doc = "Values that can be written to the field `MR1S`"]
900pub enum MR1SW {
901 #[doc = "Enabled"]
902 ENABLED,
903 #[doc = "Disabled"]
904 DISABLED,
905}
906impl MR1SW {
907 #[allow(missing_docs)]
908 #[doc(hidden)]
909 #[inline]
910 pub fn _bits(&self) -> bool {
911 match *self {
912 MR1SW::ENABLED => true,
913 MR1SW::DISABLED => false,
914 }
915 }
916}
917#[doc = r" Proxy"]
918pub struct _MR1SW<'a> {
919 w: &'a mut W,
920}
921impl<'a> _MR1SW<'a> {
922 #[doc = r" Writes `variant` to the field"]
923 #[inline]
924 pub fn variant(self, variant: MR1SW) -> &'a mut W {
925 {
926 self.bit(variant._bits())
927 }
928 }
929 #[doc = "Enabled"]
930 #[inline]
931 pub fn enabled(self) -> &'a mut W {
932 self.variant(MR1SW::ENABLED)
933 }
934 #[doc = "Disabled"]
935 #[inline]
936 pub fn disabled(self) -> &'a mut W {
937 self.variant(MR1SW::DISABLED)
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 = 5;
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 `MR2I`"]
958pub enum MR2IW {
959 #[doc = "Enabled"]
960 ENABLED,
961 #[doc = "Disabled"]
962 DISABLED,
963}
964impl MR2IW {
965 #[allow(missing_docs)]
966 #[doc(hidden)]
967 #[inline]
968 pub fn _bits(&self) -> bool {
969 match *self {
970 MR2IW::ENABLED => true,
971 MR2IW::DISABLED => false,
972 }
973 }
974}
975#[doc = r" Proxy"]
976pub struct _MR2IW<'a> {
977 w: &'a mut W,
978}
979impl<'a> _MR2IW<'a> {
980 #[doc = r" Writes `variant` to the field"]
981 #[inline]
982 pub fn variant(self, variant: MR2IW) -> &'a mut W {
983 {
984 self.bit(variant._bits())
985 }
986 }
987 #[doc = "Enabled"]
988 #[inline]
989 pub fn enabled(self) -> &'a mut W {
990 self.variant(MR2IW::ENABLED)
991 }
992 #[doc = "Disabled"]
993 #[inline]
994 pub fn disabled(self) -> &'a mut W {
995 self.variant(MR2IW::DISABLED)
996 }
997 #[doc = r" Sets the field bit"]
998 pub fn set_bit(self) -> &'a mut W {
999 self.bit(true)
1000 }
1001 #[doc = r" Clears the field bit"]
1002 pub fn clear_bit(self) -> &'a mut W {
1003 self.bit(false)
1004 }
1005 #[doc = r" Writes raw bits to the field"]
1006 #[inline]
1007 pub fn bit(self, value: bool) -> &'a mut W {
1008 const MASK: bool = true;
1009 const OFFSET: u8 = 6;
1010 self.w.bits &= !((MASK as u32) << OFFSET);
1011 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1012 self.w
1013 }
1014}
1015#[doc = "Values that can be written to the field `MR2R`"]
1016pub enum MR2RW {
1017 #[doc = "Enabled"]
1018 ENABLED,
1019 #[doc = "Disabled"]
1020 DISABLED,
1021}
1022impl MR2RW {
1023 #[allow(missing_docs)]
1024 #[doc(hidden)]
1025 #[inline]
1026 pub fn _bits(&self) -> bool {
1027 match *self {
1028 MR2RW::ENABLED => true,
1029 MR2RW::DISABLED => false,
1030 }
1031 }
1032}
1033#[doc = r" Proxy"]
1034pub struct _MR2RW<'a> {
1035 w: &'a mut W,
1036}
1037impl<'a> _MR2RW<'a> {
1038 #[doc = r" Writes `variant` to the field"]
1039 #[inline]
1040 pub fn variant(self, variant: MR2RW) -> &'a mut W {
1041 {
1042 self.bit(variant._bits())
1043 }
1044 }
1045 #[doc = "Enabled"]
1046 #[inline]
1047 pub fn enabled(self) -> &'a mut W {
1048 self.variant(MR2RW::ENABLED)
1049 }
1050 #[doc = "Disabled"]
1051 #[inline]
1052 pub fn disabled(self) -> &'a mut W {
1053 self.variant(MR2RW::DISABLED)
1054 }
1055 #[doc = r" Sets the field bit"]
1056 pub fn set_bit(self) -> &'a mut W {
1057 self.bit(true)
1058 }
1059 #[doc = r" Clears the field bit"]
1060 pub fn clear_bit(self) -> &'a mut W {
1061 self.bit(false)
1062 }
1063 #[doc = r" Writes raw bits to the field"]
1064 #[inline]
1065 pub fn bit(self, value: bool) -> &'a mut W {
1066 const MASK: bool = true;
1067 const OFFSET: u8 = 7;
1068 self.w.bits &= !((MASK as u32) << OFFSET);
1069 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1070 self.w
1071 }
1072}
1073#[doc = "Values that can be written to the field `MR2S`"]
1074pub enum MR2SW {
1075 #[doc = "Enabled"]
1076 ENABLED,
1077 #[doc = "Disabled"]
1078 DISABLED,
1079}
1080impl MR2SW {
1081 #[allow(missing_docs)]
1082 #[doc(hidden)]
1083 #[inline]
1084 pub fn _bits(&self) -> bool {
1085 match *self {
1086 MR2SW::ENABLED => true,
1087 MR2SW::DISABLED => false,
1088 }
1089 }
1090}
1091#[doc = r" Proxy"]
1092pub struct _MR2SW<'a> {
1093 w: &'a mut W,
1094}
1095impl<'a> _MR2SW<'a> {
1096 #[doc = r" Writes `variant` to the field"]
1097 #[inline]
1098 pub fn variant(self, variant: MR2SW) -> &'a mut W {
1099 {
1100 self.bit(variant._bits())
1101 }
1102 }
1103 #[doc = "Enabled"]
1104 #[inline]
1105 pub fn enabled(self) -> &'a mut W {
1106 self.variant(MR2SW::ENABLED)
1107 }
1108 #[doc = "Disabled"]
1109 #[inline]
1110 pub fn disabled(self) -> &'a mut W {
1111 self.variant(MR2SW::DISABLED)
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 = 8;
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 `MR3I`"]
1132pub enum MR3IW {
1133 #[doc = "Enabled"]
1134 ENABLED,
1135 #[doc = "Disabled"]
1136 DISABLED,
1137}
1138impl MR3IW {
1139 #[allow(missing_docs)]
1140 #[doc(hidden)]
1141 #[inline]
1142 pub fn _bits(&self) -> bool {
1143 match *self {
1144 MR3IW::ENABLED => true,
1145 MR3IW::DISABLED => false,
1146 }
1147 }
1148}
1149#[doc = r" Proxy"]
1150pub struct _MR3IW<'a> {
1151 w: &'a mut W,
1152}
1153impl<'a> _MR3IW<'a> {
1154 #[doc = r" Writes `variant` to the field"]
1155 #[inline]
1156 pub fn variant(self, variant: MR3IW) -> &'a mut W {
1157 {
1158 self.bit(variant._bits())
1159 }
1160 }
1161 #[doc = "Enabled"]
1162 #[inline]
1163 pub fn enabled(self) -> &'a mut W {
1164 self.variant(MR3IW::ENABLED)
1165 }
1166 #[doc = "Disabled"]
1167 #[inline]
1168 pub fn disabled(self) -> &'a mut W {
1169 self.variant(MR3IW::DISABLED)
1170 }
1171 #[doc = r" Sets the field bit"]
1172 pub fn set_bit(self) -> &'a mut W {
1173 self.bit(true)
1174 }
1175 #[doc = r" Clears the field bit"]
1176 pub fn clear_bit(self) -> &'a mut W {
1177 self.bit(false)
1178 }
1179 #[doc = r" Writes raw bits to the field"]
1180 #[inline]
1181 pub fn bit(self, value: bool) -> &'a mut W {
1182 const MASK: bool = true;
1183 const OFFSET: u8 = 9;
1184 self.w.bits &= !((MASK as u32) << OFFSET);
1185 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1186 self.w
1187 }
1188}
1189#[doc = "Values that can be written to the field `MR3R`"]
1190pub enum MR3RW {
1191 #[doc = "Enabled"]
1192 ENABLED,
1193 #[doc = "Disabled"]
1194 DISABLED,
1195}
1196impl MR3RW {
1197 #[allow(missing_docs)]
1198 #[doc(hidden)]
1199 #[inline]
1200 pub fn _bits(&self) -> bool {
1201 match *self {
1202 MR3RW::ENABLED => true,
1203 MR3RW::DISABLED => false,
1204 }
1205 }
1206}
1207#[doc = r" Proxy"]
1208pub struct _MR3RW<'a> {
1209 w: &'a mut W,
1210}
1211impl<'a> _MR3RW<'a> {
1212 #[doc = r" Writes `variant` to the field"]
1213 #[inline]
1214 pub fn variant(self, variant: MR3RW) -> &'a mut W {
1215 {
1216 self.bit(variant._bits())
1217 }
1218 }
1219 #[doc = "Enabled"]
1220 #[inline]
1221 pub fn enabled(self) -> &'a mut W {
1222 self.variant(MR3RW::ENABLED)
1223 }
1224 #[doc = "Disabled"]
1225 #[inline]
1226 pub fn disabled(self) -> &'a mut W {
1227 self.variant(MR3RW::DISABLED)
1228 }
1229 #[doc = r" Sets the field bit"]
1230 pub fn set_bit(self) -> &'a mut W {
1231 self.bit(true)
1232 }
1233 #[doc = r" Clears the field bit"]
1234 pub fn clear_bit(self) -> &'a mut W {
1235 self.bit(false)
1236 }
1237 #[doc = r" Writes raw bits to the field"]
1238 #[inline]
1239 pub fn bit(self, value: bool) -> &'a mut W {
1240 const MASK: bool = true;
1241 const OFFSET: u8 = 10;
1242 self.w.bits &= !((MASK as u32) << OFFSET);
1243 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1244 self.w
1245 }
1246}
1247#[doc = "Values that can be written to the field `MR3S`"]
1248pub enum MR3SW {
1249 #[doc = "Enabled"]
1250 ENABLED,
1251 #[doc = "Disabled"]
1252 DISABLED,
1253}
1254impl MR3SW {
1255 #[allow(missing_docs)]
1256 #[doc(hidden)]
1257 #[inline]
1258 pub fn _bits(&self) -> bool {
1259 match *self {
1260 MR3SW::ENABLED => true,
1261 MR3SW::DISABLED => false,
1262 }
1263 }
1264}
1265#[doc = r" Proxy"]
1266pub struct _MR3SW<'a> {
1267 w: &'a mut W,
1268}
1269impl<'a> _MR3SW<'a> {
1270 #[doc = r" Writes `variant` to the field"]
1271 #[inline]
1272 pub fn variant(self, variant: MR3SW) -> &'a mut W {
1273 {
1274 self.bit(variant._bits())
1275 }
1276 }
1277 #[doc = "Enabled"]
1278 #[inline]
1279 pub fn enabled(self) -> &'a mut W {
1280 self.variant(MR3SW::ENABLED)
1281 }
1282 #[doc = "Disabled"]
1283 #[inline]
1284 pub fn disabled(self) -> &'a mut W {
1285 self.variant(MR3SW::DISABLED)
1286 }
1287 #[doc = r" Sets the field bit"]
1288 pub fn set_bit(self) -> &'a mut W {
1289 self.bit(true)
1290 }
1291 #[doc = r" Clears the field bit"]
1292 pub fn clear_bit(self) -> &'a mut W {
1293 self.bit(false)
1294 }
1295 #[doc = r" Writes raw bits to the field"]
1296 #[inline]
1297 pub fn bit(self, value: bool) -> &'a mut W {
1298 const MASK: bool = true;
1299 const OFFSET: u8 = 11;
1300 self.w.bits &= !((MASK as u32) << OFFSET);
1301 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1302 self.w
1303 }
1304}
1305impl R {
1306 #[doc = r" Value of the register as raw bits"]
1307 #[inline]
1308 pub fn bits(&self) -> u32 {
1309 self.bits
1310 }
1311 #[doc = "Bit 0 - Interrupt on MR0: an interrupt is generated when MR0 matches the value in the TC."]
1312 #[inline]
1313 pub fn mr0i(&self) -> MR0IR {
1314 MR0IR::_from({
1315 const MASK: bool = true;
1316 const OFFSET: u8 = 0;
1317 ((self.bits >> OFFSET) & MASK as u32) != 0
1318 })
1319 }
1320 #[doc = "Bit 1 - Reset on MR0: the TC will be reset if MR0 matches it."]
1321 #[inline]
1322 pub fn mr0r(&self) -> MR0RR {
1323 MR0RR::_from({
1324 const MASK: bool = true;
1325 const OFFSET: u8 = 1;
1326 ((self.bits >> OFFSET) & MASK as u32) != 0
1327 })
1328 }
1329 #[doc = "Bit 2 - Stop on MR0: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR0 matches the TC."]
1330 #[inline]
1331 pub fn mr0s(&self) -> MR0SR {
1332 MR0SR::_from({
1333 const MASK: bool = true;
1334 const OFFSET: u8 = 2;
1335 ((self.bits >> OFFSET) & MASK as u32) != 0
1336 })
1337 }
1338 #[doc = "Bit 3 - Interrupt on MR1: an interrupt is generated when MR1 matches the value in the TC."]
1339 #[inline]
1340 pub fn mr1i(&self) -> MR1IR {
1341 MR1IR::_from({
1342 const MASK: bool = true;
1343 const OFFSET: u8 = 3;
1344 ((self.bits >> OFFSET) & MASK as u32) != 0
1345 })
1346 }
1347 #[doc = "Bit 4 - Reset on MR1: the TC will be reset if MR1 matches it."]
1348 #[inline]
1349 pub fn mr1r(&self) -> MR1RR {
1350 MR1RR::_from({
1351 const MASK: bool = true;
1352 const OFFSET: u8 = 4;
1353 ((self.bits >> OFFSET) & MASK as u32) != 0
1354 })
1355 }
1356 #[doc = "Bit 5 - Stop on MR1: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR1 matches the TC."]
1357 #[inline]
1358 pub fn mr1s(&self) -> MR1SR {
1359 MR1SR::_from({
1360 const MASK: bool = true;
1361 const OFFSET: u8 = 5;
1362 ((self.bits >> OFFSET) & MASK as u32) != 0
1363 })
1364 }
1365 #[doc = "Bit 6 - Interrupt on MR2: an interrupt is generated when MR2 matches the value in the TC."]
1366 #[inline]
1367 pub fn mr2i(&self) -> MR2IR {
1368 MR2IR::_from({
1369 const MASK: bool = true;
1370 const OFFSET: u8 = 6;
1371 ((self.bits >> OFFSET) & MASK as u32) != 0
1372 })
1373 }
1374 #[doc = "Bit 7 - Reset on MR2: the TC will be reset if MR2 matches it."]
1375 #[inline]
1376 pub fn mr2r(&self) -> MR2RR {
1377 MR2RR::_from({
1378 const MASK: bool = true;
1379 const OFFSET: u8 = 7;
1380 ((self.bits >> OFFSET) & MASK as u32) != 0
1381 })
1382 }
1383 #[doc = "Bit 8 - Stop on MR2: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR2 matches the TC."]
1384 #[inline]
1385 pub fn mr2s(&self) -> MR2SR {
1386 MR2SR::_from({
1387 const MASK: bool = true;
1388 const OFFSET: u8 = 8;
1389 ((self.bits >> OFFSET) & MASK as u32) != 0
1390 })
1391 }
1392 #[doc = "Bit 9 - Interrupt on MR3: an interrupt is generated when MR3 matches the value in the TC."]
1393 #[inline]
1394 pub fn mr3i(&self) -> MR3IR {
1395 MR3IR::_from({
1396 const MASK: bool = true;
1397 const OFFSET: u8 = 9;
1398 ((self.bits >> OFFSET) & MASK as u32) != 0
1399 })
1400 }
1401 #[doc = "Bit 10 - Reset on MR3: the TC will be reset if MR3 matches it."]
1402 #[inline]
1403 pub fn mr3r(&self) -> MR3RR {
1404 MR3RR::_from({
1405 const MASK: bool = true;
1406 const OFFSET: u8 = 10;
1407 ((self.bits >> OFFSET) & MASK as u32) != 0
1408 })
1409 }
1410 #[doc = "Bit 11 - Stop on MR3: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR3 matches the TC."]
1411 #[inline]
1412 pub fn mr3s(&self) -> MR3SR {
1413 MR3SR::_from({
1414 const MASK: bool = true;
1415 const OFFSET: u8 = 11;
1416 ((self.bits >> OFFSET) & MASK as u32) != 0
1417 })
1418 }
1419}
1420impl W {
1421 #[doc = r" Reset value of the register"]
1422 #[inline]
1423 pub fn reset_value() -> W {
1424 W { bits: 0 }
1425 }
1426 #[doc = r" Writes raw bits to the register"]
1427 #[inline]
1428 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1429 self.bits = bits;
1430 self
1431 }
1432 #[doc = "Bit 0 - Interrupt on MR0: an interrupt is generated when MR0 matches the value in the TC."]
1433 #[inline]
1434 pub fn mr0i(&mut self) -> _MR0IW {
1435 _MR0IW { w: self }
1436 }
1437 #[doc = "Bit 1 - Reset on MR0: the TC will be reset if MR0 matches it."]
1438 #[inline]
1439 pub fn mr0r(&mut self) -> _MR0RW {
1440 _MR0RW { w: self }
1441 }
1442 #[doc = "Bit 2 - Stop on MR0: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR0 matches the TC."]
1443 #[inline]
1444 pub fn mr0s(&mut self) -> _MR0SW {
1445 _MR0SW { w: self }
1446 }
1447 #[doc = "Bit 3 - Interrupt on MR1: an interrupt is generated when MR1 matches the value in the TC."]
1448 #[inline]
1449 pub fn mr1i(&mut self) -> _MR1IW {
1450 _MR1IW { w: self }
1451 }
1452 #[doc = "Bit 4 - Reset on MR1: the TC will be reset if MR1 matches it."]
1453 #[inline]
1454 pub fn mr1r(&mut self) -> _MR1RW {
1455 _MR1RW { w: self }
1456 }
1457 #[doc = "Bit 5 - Stop on MR1: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR1 matches the TC."]
1458 #[inline]
1459 pub fn mr1s(&mut self) -> _MR1SW {
1460 _MR1SW { w: self }
1461 }
1462 #[doc = "Bit 6 - Interrupt on MR2: an interrupt is generated when MR2 matches the value in the TC."]
1463 #[inline]
1464 pub fn mr2i(&mut self) -> _MR2IW {
1465 _MR2IW { w: self }
1466 }
1467 #[doc = "Bit 7 - Reset on MR2: the TC will be reset if MR2 matches it."]
1468 #[inline]
1469 pub fn mr2r(&mut self) -> _MR2RW {
1470 _MR2RW { w: self }
1471 }
1472 #[doc = "Bit 8 - Stop on MR2: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR2 matches the TC."]
1473 #[inline]
1474 pub fn mr2s(&mut self) -> _MR2SW {
1475 _MR2SW { w: self }
1476 }
1477 #[doc = "Bit 9 - Interrupt on MR3: an interrupt is generated when MR3 matches the value in the TC."]
1478 #[inline]
1479 pub fn mr3i(&mut self) -> _MR3IW {
1480 _MR3IW { w: self }
1481 }
1482 #[doc = "Bit 10 - Reset on MR3: the TC will be reset if MR3 matches it."]
1483 #[inline]
1484 pub fn mr3r(&mut self) -> _MR3RW {
1485 _MR3RW { w: self }
1486 }
1487 #[doc = "Bit 11 - Stop on MR3: the TC and PC will be stopped and TCR\\[0\\] will be set to 0 if MR3 matches the TC."]
1488 #[inline]
1489 pub fn mr3s(&mut self) -> _MR3SW {
1490 _MR3SW { w: self }
1491 }
1492}