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::SHCSR {
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 `MEMFAULTACT`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum MEMFAULTACTR {
48 #[doc = "exception is not active"]
49 _0,
50 #[doc = "exception is active"]
51 _1,
52}
53impl MEMFAULTACTR {
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 MEMFAULTACTR::_0 => false,
69 MEMFAULTACTR::_1 => true,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> MEMFAULTACTR {
76 match value {
77 false => MEMFAULTACTR::_0,
78 true => MEMFAULTACTR::_1,
79 }
80 }
81 #[doc = "Checks if the value of the field is `_0`"]
82 #[inline]
83 pub fn is_0(&self) -> bool {
84 *self == MEMFAULTACTR::_0
85 }
86 #[doc = "Checks if the value of the field is `_1`"]
87 #[inline]
88 pub fn is_1(&self) -> bool {
89 *self == MEMFAULTACTR::_1
90 }
91}
92#[doc = "Possible values of the field `BUSFAULTACT`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum BUSFAULTACTR {
95 #[doc = "exception is not active"]
96 _0,
97 #[doc = "exception is active"]
98 _1,
99}
100impl BUSFAULTACTR {
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 BUSFAULTACTR::_0 => false,
116 BUSFAULTACTR::_1 => true,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> BUSFAULTACTR {
123 match value {
124 false => BUSFAULTACTR::_0,
125 true => BUSFAULTACTR::_1,
126 }
127 }
128 #[doc = "Checks if the value of the field is `_0`"]
129 #[inline]
130 pub fn is_0(&self) -> bool {
131 *self == BUSFAULTACTR::_0
132 }
133 #[doc = "Checks if the value of the field is `_1`"]
134 #[inline]
135 pub fn is_1(&self) -> bool {
136 *self == BUSFAULTACTR::_1
137 }
138}
139#[doc = "Possible values of the field `USGFAULTACT`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum USGFAULTACTR {
142 #[doc = "exception is not active"]
143 _0,
144 #[doc = "exception is active"]
145 _1,
146}
147impl USGFAULTACTR {
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 USGFAULTACTR::_0 => false,
163 USGFAULTACTR::_1 => true,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> USGFAULTACTR {
170 match value {
171 false => USGFAULTACTR::_0,
172 true => USGFAULTACTR::_1,
173 }
174 }
175 #[doc = "Checks if the value of the field is `_0`"]
176 #[inline]
177 pub fn is_0(&self) -> bool {
178 *self == USGFAULTACTR::_0
179 }
180 #[doc = "Checks if the value of the field is `_1`"]
181 #[inline]
182 pub fn is_1(&self) -> bool {
183 *self == USGFAULTACTR::_1
184 }
185}
186#[doc = "Possible values of the field `SVCALLACT`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum SVCALLACTR {
189 #[doc = "exception is not active"]
190 _0,
191 #[doc = "exception is active"]
192 _1,
193}
194impl SVCALLACTR {
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 SVCALLACTR::_0 => false,
210 SVCALLACTR::_1 => true,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> SVCALLACTR {
217 match value {
218 false => SVCALLACTR::_0,
219 true => SVCALLACTR::_1,
220 }
221 }
222 #[doc = "Checks if the value of the field is `_0`"]
223 #[inline]
224 pub fn is_0(&self) -> bool {
225 *self == SVCALLACTR::_0
226 }
227 #[doc = "Checks if the value of the field is `_1`"]
228 #[inline]
229 pub fn is_1(&self) -> bool {
230 *self == SVCALLACTR::_1
231 }
232}
233#[doc = "Possible values of the field `MONITORACT`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum MONITORACTR {
236 #[doc = "exception is not active"]
237 _0,
238 #[doc = "exception is active"]
239 _1,
240}
241impl MONITORACTR {
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 MONITORACTR::_0 => false,
257 MONITORACTR::_1 => true,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> MONITORACTR {
264 match value {
265 false => MONITORACTR::_0,
266 true => MONITORACTR::_1,
267 }
268 }
269 #[doc = "Checks if the value of the field is `_0`"]
270 #[inline]
271 pub fn is_0(&self) -> bool {
272 *self == MONITORACTR::_0
273 }
274 #[doc = "Checks if the value of the field is `_1`"]
275 #[inline]
276 pub fn is_1(&self) -> bool {
277 *self == MONITORACTR::_1
278 }
279}
280#[doc = "Possible values of the field `PENDSVACT`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum PENDSVACTR {
283 #[doc = "exception is not active"]
284 _0,
285 #[doc = "exception is active"]
286 _1,
287}
288impl PENDSVACTR {
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 PENDSVACTR::_0 => false,
304 PENDSVACTR::_1 => true,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> PENDSVACTR {
311 match value {
312 false => PENDSVACTR::_0,
313 true => PENDSVACTR::_1,
314 }
315 }
316 #[doc = "Checks if the value of the field is `_0`"]
317 #[inline]
318 pub fn is_0(&self) -> bool {
319 *self == PENDSVACTR::_0
320 }
321 #[doc = "Checks if the value of the field is `_1`"]
322 #[inline]
323 pub fn is_1(&self) -> bool {
324 *self == PENDSVACTR::_1
325 }
326}
327#[doc = "Possible values of the field `SYSTICKACT`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum SYSTICKACTR {
330 #[doc = "exception is not active"]
331 _0,
332 #[doc = "exception is active"]
333 _1,
334}
335impl SYSTICKACTR {
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 SYSTICKACTR::_0 => false,
351 SYSTICKACTR::_1 => true,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> SYSTICKACTR {
358 match value {
359 false => SYSTICKACTR::_0,
360 true => SYSTICKACTR::_1,
361 }
362 }
363 #[doc = "Checks if the value of the field is `_0`"]
364 #[inline]
365 pub fn is_0(&self) -> bool {
366 *self == SYSTICKACTR::_0
367 }
368 #[doc = "Checks if the value of the field is `_1`"]
369 #[inline]
370 pub fn is_1(&self) -> bool {
371 *self == SYSTICKACTR::_1
372 }
373}
374#[doc = "Possible values of the field `USGFAULTPENDED`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum USGFAULTPENDEDR {
377 #[doc = "exception is not pending"]
378 _0,
379 #[doc = "exception is pending"]
380 _1,
381}
382impl USGFAULTPENDEDR {
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 USGFAULTPENDEDR::_0 => false,
398 USGFAULTPENDEDR::_1 => true,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> USGFAULTPENDEDR {
405 match value {
406 false => USGFAULTPENDEDR::_0,
407 true => USGFAULTPENDEDR::_1,
408 }
409 }
410 #[doc = "Checks if the value of the field is `_0`"]
411 #[inline]
412 pub fn is_0(&self) -> bool {
413 *self == USGFAULTPENDEDR::_0
414 }
415 #[doc = "Checks if the value of the field is `_1`"]
416 #[inline]
417 pub fn is_1(&self) -> bool {
418 *self == USGFAULTPENDEDR::_1
419 }
420}
421#[doc = "Possible values of the field `MEMFAULTPENDED`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum MEMFAULTPENDEDR {
424 #[doc = "exception is not pending"]
425 _0,
426 #[doc = "exception is pending"]
427 _1,
428}
429impl MEMFAULTPENDEDR {
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 MEMFAULTPENDEDR::_0 => false,
445 MEMFAULTPENDEDR::_1 => true,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> MEMFAULTPENDEDR {
452 match value {
453 false => MEMFAULTPENDEDR::_0,
454 true => MEMFAULTPENDEDR::_1,
455 }
456 }
457 #[doc = "Checks if the value of the field is `_0`"]
458 #[inline]
459 pub fn is_0(&self) -> bool {
460 *self == MEMFAULTPENDEDR::_0
461 }
462 #[doc = "Checks if the value of the field is `_1`"]
463 #[inline]
464 pub fn is_1(&self) -> bool {
465 *self == MEMFAULTPENDEDR::_1
466 }
467}
468#[doc = "Possible values of the field `BUSFAULTPENDED`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum BUSFAULTPENDEDR {
471 #[doc = "exception is not pending"]
472 _0,
473 #[doc = "exception is pending"]
474 _1,
475}
476impl BUSFAULTPENDEDR {
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 BUSFAULTPENDEDR::_0 => false,
492 BUSFAULTPENDEDR::_1 => true,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> BUSFAULTPENDEDR {
499 match value {
500 false => BUSFAULTPENDEDR::_0,
501 true => BUSFAULTPENDEDR::_1,
502 }
503 }
504 #[doc = "Checks if the value of the field is `_0`"]
505 #[inline]
506 pub fn is_0(&self) -> bool {
507 *self == BUSFAULTPENDEDR::_0
508 }
509 #[doc = "Checks if the value of the field is `_1`"]
510 #[inline]
511 pub fn is_1(&self) -> bool {
512 *self == BUSFAULTPENDEDR::_1
513 }
514}
515#[doc = "Possible values of the field `SVCALLPENDED`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum SVCALLPENDEDR {
518 #[doc = "exception is not pending"]
519 _0,
520 #[doc = "exception is pending"]
521 _1,
522}
523impl SVCALLPENDEDR {
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 SVCALLPENDEDR::_0 => false,
539 SVCALLPENDEDR::_1 => true,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> SVCALLPENDEDR {
546 match value {
547 false => SVCALLPENDEDR::_0,
548 true => SVCALLPENDEDR::_1,
549 }
550 }
551 #[doc = "Checks if the value of the field is `_0`"]
552 #[inline]
553 pub fn is_0(&self) -> bool {
554 *self == SVCALLPENDEDR::_0
555 }
556 #[doc = "Checks if the value of the field is `_1`"]
557 #[inline]
558 pub fn is_1(&self) -> bool {
559 *self == SVCALLPENDEDR::_1
560 }
561}
562#[doc = "Possible values of the field `MEMFAULTENA`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum MEMFAULTENAR {
565 #[doc = "disable the exception"]
566 _0,
567 #[doc = "enable the exception"]
568 _1,
569}
570impl MEMFAULTENAR {
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 MEMFAULTENAR::_0 => false,
586 MEMFAULTENAR::_1 => true,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> MEMFAULTENAR {
593 match value {
594 false => MEMFAULTENAR::_0,
595 true => MEMFAULTENAR::_1,
596 }
597 }
598 #[doc = "Checks if the value of the field is `_0`"]
599 #[inline]
600 pub fn is_0(&self) -> bool {
601 *self == MEMFAULTENAR::_0
602 }
603 #[doc = "Checks if the value of the field is `_1`"]
604 #[inline]
605 pub fn is_1(&self) -> bool {
606 *self == MEMFAULTENAR::_1
607 }
608}
609#[doc = "Possible values of the field `BUSFAULTENA`"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum BUSFAULTENAR {
612 #[doc = "disable the exception"]
613 _0,
614 #[doc = "enable the exception"]
615 _1,
616}
617impl BUSFAULTENAR {
618 #[doc = r" Returns `true` if the bit is clear (0)"]
619 #[inline]
620 pub fn bit_is_clear(&self) -> bool {
621 !self.bit()
622 }
623 #[doc = r" Returns `true` if the bit is set (1)"]
624 #[inline]
625 pub fn bit_is_set(&self) -> bool {
626 self.bit()
627 }
628 #[doc = r" Value of the field as raw bits"]
629 #[inline]
630 pub fn bit(&self) -> bool {
631 match *self {
632 BUSFAULTENAR::_0 => false,
633 BUSFAULTENAR::_1 => true,
634 }
635 }
636 #[allow(missing_docs)]
637 #[doc(hidden)]
638 #[inline]
639 pub fn _from(value: bool) -> BUSFAULTENAR {
640 match value {
641 false => BUSFAULTENAR::_0,
642 true => BUSFAULTENAR::_1,
643 }
644 }
645 #[doc = "Checks if the value of the field is `_0`"]
646 #[inline]
647 pub fn is_0(&self) -> bool {
648 *self == BUSFAULTENAR::_0
649 }
650 #[doc = "Checks if the value of the field is `_1`"]
651 #[inline]
652 pub fn is_1(&self) -> bool {
653 *self == BUSFAULTENAR::_1
654 }
655}
656#[doc = "Possible values of the field `USGFAULTENA`"]
657#[derive(Clone, Copy, Debug, PartialEq)]
658pub enum USGFAULTENAR {
659 #[doc = "disable the exception"]
660 _0,
661 #[doc = "enable the exception"]
662 _1,
663}
664impl USGFAULTENAR {
665 #[doc = r" Returns `true` if the bit is clear (0)"]
666 #[inline]
667 pub fn bit_is_clear(&self) -> bool {
668 !self.bit()
669 }
670 #[doc = r" Returns `true` if the bit is set (1)"]
671 #[inline]
672 pub fn bit_is_set(&self) -> bool {
673 self.bit()
674 }
675 #[doc = r" Value of the field as raw bits"]
676 #[inline]
677 pub fn bit(&self) -> bool {
678 match *self {
679 USGFAULTENAR::_0 => false,
680 USGFAULTENAR::_1 => true,
681 }
682 }
683 #[allow(missing_docs)]
684 #[doc(hidden)]
685 #[inline]
686 pub fn _from(value: bool) -> USGFAULTENAR {
687 match value {
688 false => USGFAULTENAR::_0,
689 true => USGFAULTENAR::_1,
690 }
691 }
692 #[doc = "Checks if the value of the field is `_0`"]
693 #[inline]
694 pub fn is_0(&self) -> bool {
695 *self == USGFAULTENAR::_0
696 }
697 #[doc = "Checks if the value of the field is `_1`"]
698 #[inline]
699 pub fn is_1(&self) -> bool {
700 *self == USGFAULTENAR::_1
701 }
702}
703#[doc = "Values that can be written to the field `MEMFAULTACT`"]
704pub enum MEMFAULTACTW {
705 #[doc = "exception is not active"]
706 _0,
707 #[doc = "exception is active"]
708 _1,
709}
710impl MEMFAULTACTW {
711 #[allow(missing_docs)]
712 #[doc(hidden)]
713 #[inline]
714 pub fn _bits(&self) -> bool {
715 match *self {
716 MEMFAULTACTW::_0 => false,
717 MEMFAULTACTW::_1 => true,
718 }
719 }
720}
721#[doc = r" Proxy"]
722pub struct _MEMFAULTACTW<'a> {
723 w: &'a mut W,
724}
725impl<'a> _MEMFAULTACTW<'a> {
726 #[doc = r" Writes `variant` to the field"]
727 #[inline]
728 pub fn variant(self, variant: MEMFAULTACTW) -> &'a mut W {
729 {
730 self.bit(variant._bits())
731 }
732 }
733 #[doc = "exception is not active"]
734 #[inline]
735 pub fn _0(self) -> &'a mut W {
736 self.variant(MEMFAULTACTW::_0)
737 }
738 #[doc = "exception is active"]
739 #[inline]
740 pub fn _1(self) -> &'a mut W {
741 self.variant(MEMFAULTACTW::_1)
742 }
743 #[doc = r" Sets the field bit"]
744 pub fn set_bit(self) -> &'a mut W {
745 self.bit(true)
746 }
747 #[doc = r" Clears the field bit"]
748 pub fn clear_bit(self) -> &'a mut W {
749 self.bit(false)
750 }
751 #[doc = r" Writes raw bits to the field"]
752 #[inline]
753 pub fn bit(self, value: bool) -> &'a mut W {
754 const MASK: bool = true;
755 const OFFSET: u8 = 0;
756 self.w.bits &= !((MASK as u32) << OFFSET);
757 self.w.bits |= ((value & MASK) as u32) << OFFSET;
758 self.w
759 }
760}
761#[doc = "Values that can be written to the field `BUSFAULTACT`"]
762pub enum BUSFAULTACTW {
763 #[doc = "exception is not active"]
764 _0,
765 #[doc = "exception is active"]
766 _1,
767}
768impl BUSFAULTACTW {
769 #[allow(missing_docs)]
770 #[doc(hidden)]
771 #[inline]
772 pub fn _bits(&self) -> bool {
773 match *self {
774 BUSFAULTACTW::_0 => false,
775 BUSFAULTACTW::_1 => true,
776 }
777 }
778}
779#[doc = r" Proxy"]
780pub struct _BUSFAULTACTW<'a> {
781 w: &'a mut W,
782}
783impl<'a> _BUSFAULTACTW<'a> {
784 #[doc = r" Writes `variant` to the field"]
785 #[inline]
786 pub fn variant(self, variant: BUSFAULTACTW) -> &'a mut W {
787 {
788 self.bit(variant._bits())
789 }
790 }
791 #[doc = "exception is not active"]
792 #[inline]
793 pub fn _0(self) -> &'a mut W {
794 self.variant(BUSFAULTACTW::_0)
795 }
796 #[doc = "exception is active"]
797 #[inline]
798 pub fn _1(self) -> &'a mut W {
799 self.variant(BUSFAULTACTW::_1)
800 }
801 #[doc = r" Sets the field bit"]
802 pub fn set_bit(self) -> &'a mut W {
803 self.bit(true)
804 }
805 #[doc = r" Clears the field bit"]
806 pub fn clear_bit(self) -> &'a mut W {
807 self.bit(false)
808 }
809 #[doc = r" Writes raw bits to the field"]
810 #[inline]
811 pub fn bit(self, value: bool) -> &'a mut W {
812 const MASK: bool = true;
813 const OFFSET: u8 = 1;
814 self.w.bits &= !((MASK as u32) << OFFSET);
815 self.w.bits |= ((value & MASK) as u32) << OFFSET;
816 self.w
817 }
818}
819#[doc = "Values that can be written to the field `USGFAULTACT`"]
820pub enum USGFAULTACTW {
821 #[doc = "exception is not active"]
822 _0,
823 #[doc = "exception is active"]
824 _1,
825}
826impl USGFAULTACTW {
827 #[allow(missing_docs)]
828 #[doc(hidden)]
829 #[inline]
830 pub fn _bits(&self) -> bool {
831 match *self {
832 USGFAULTACTW::_0 => false,
833 USGFAULTACTW::_1 => true,
834 }
835 }
836}
837#[doc = r" Proxy"]
838pub struct _USGFAULTACTW<'a> {
839 w: &'a mut W,
840}
841impl<'a> _USGFAULTACTW<'a> {
842 #[doc = r" Writes `variant` to the field"]
843 #[inline]
844 pub fn variant(self, variant: USGFAULTACTW) -> &'a mut W {
845 {
846 self.bit(variant._bits())
847 }
848 }
849 #[doc = "exception is not active"]
850 #[inline]
851 pub fn _0(self) -> &'a mut W {
852 self.variant(USGFAULTACTW::_0)
853 }
854 #[doc = "exception is active"]
855 #[inline]
856 pub fn _1(self) -> &'a mut W {
857 self.variant(USGFAULTACTW::_1)
858 }
859 #[doc = r" Sets the field bit"]
860 pub fn set_bit(self) -> &'a mut W {
861 self.bit(true)
862 }
863 #[doc = r" Clears the field bit"]
864 pub fn clear_bit(self) -> &'a mut W {
865 self.bit(false)
866 }
867 #[doc = r" Writes raw bits to the field"]
868 #[inline]
869 pub fn bit(self, value: bool) -> &'a mut W {
870 const MASK: bool = true;
871 const OFFSET: u8 = 3;
872 self.w.bits &= !((MASK as u32) << OFFSET);
873 self.w.bits |= ((value & MASK) as u32) << OFFSET;
874 self.w
875 }
876}
877#[doc = "Values that can be written to the field `SVCALLACT`"]
878pub enum SVCALLACTW {
879 #[doc = "exception is not active"]
880 _0,
881 #[doc = "exception is active"]
882 _1,
883}
884impl SVCALLACTW {
885 #[allow(missing_docs)]
886 #[doc(hidden)]
887 #[inline]
888 pub fn _bits(&self) -> bool {
889 match *self {
890 SVCALLACTW::_0 => false,
891 SVCALLACTW::_1 => true,
892 }
893 }
894}
895#[doc = r" Proxy"]
896pub struct _SVCALLACTW<'a> {
897 w: &'a mut W,
898}
899impl<'a> _SVCALLACTW<'a> {
900 #[doc = r" Writes `variant` to the field"]
901 #[inline]
902 pub fn variant(self, variant: SVCALLACTW) -> &'a mut W {
903 {
904 self.bit(variant._bits())
905 }
906 }
907 #[doc = "exception is not active"]
908 #[inline]
909 pub fn _0(self) -> &'a mut W {
910 self.variant(SVCALLACTW::_0)
911 }
912 #[doc = "exception is active"]
913 #[inline]
914 pub fn _1(self) -> &'a mut W {
915 self.variant(SVCALLACTW::_1)
916 }
917 #[doc = r" Sets the field bit"]
918 pub fn set_bit(self) -> &'a mut W {
919 self.bit(true)
920 }
921 #[doc = r" Clears the field bit"]
922 pub fn clear_bit(self) -> &'a mut W {
923 self.bit(false)
924 }
925 #[doc = r" Writes raw bits to the field"]
926 #[inline]
927 pub fn bit(self, value: bool) -> &'a mut W {
928 const MASK: bool = true;
929 const OFFSET: u8 = 7;
930 self.w.bits &= !((MASK as u32) << OFFSET);
931 self.w.bits |= ((value & MASK) as u32) << OFFSET;
932 self.w
933 }
934}
935#[doc = "Values that can be written to the field `MONITORACT`"]
936pub enum MONITORACTW {
937 #[doc = "exception is not active"]
938 _0,
939 #[doc = "exception is active"]
940 _1,
941}
942impl MONITORACTW {
943 #[allow(missing_docs)]
944 #[doc(hidden)]
945 #[inline]
946 pub fn _bits(&self) -> bool {
947 match *self {
948 MONITORACTW::_0 => false,
949 MONITORACTW::_1 => true,
950 }
951 }
952}
953#[doc = r" Proxy"]
954pub struct _MONITORACTW<'a> {
955 w: &'a mut W,
956}
957impl<'a> _MONITORACTW<'a> {
958 #[doc = r" Writes `variant` to the field"]
959 #[inline]
960 pub fn variant(self, variant: MONITORACTW) -> &'a mut W {
961 {
962 self.bit(variant._bits())
963 }
964 }
965 #[doc = "exception is not active"]
966 #[inline]
967 pub fn _0(self) -> &'a mut W {
968 self.variant(MONITORACTW::_0)
969 }
970 #[doc = "exception is active"]
971 #[inline]
972 pub fn _1(self) -> &'a mut W {
973 self.variant(MONITORACTW::_1)
974 }
975 #[doc = r" Sets the field bit"]
976 pub fn set_bit(self) -> &'a mut W {
977 self.bit(true)
978 }
979 #[doc = r" Clears the field bit"]
980 pub fn clear_bit(self) -> &'a mut W {
981 self.bit(false)
982 }
983 #[doc = r" Writes raw bits to the field"]
984 #[inline]
985 pub fn bit(self, value: bool) -> &'a mut W {
986 const MASK: bool = true;
987 const OFFSET: u8 = 8;
988 self.w.bits &= !((MASK as u32) << OFFSET);
989 self.w.bits |= ((value & MASK) as u32) << OFFSET;
990 self.w
991 }
992}
993#[doc = "Values that can be written to the field `PENDSVACT`"]
994pub enum PENDSVACTW {
995 #[doc = "exception is not active"]
996 _0,
997 #[doc = "exception is active"]
998 _1,
999}
1000impl PENDSVACTW {
1001 #[allow(missing_docs)]
1002 #[doc(hidden)]
1003 #[inline]
1004 pub fn _bits(&self) -> bool {
1005 match *self {
1006 PENDSVACTW::_0 => false,
1007 PENDSVACTW::_1 => true,
1008 }
1009 }
1010}
1011#[doc = r" Proxy"]
1012pub struct _PENDSVACTW<'a> {
1013 w: &'a mut W,
1014}
1015impl<'a> _PENDSVACTW<'a> {
1016 #[doc = r" Writes `variant` to the field"]
1017 #[inline]
1018 pub fn variant(self, variant: PENDSVACTW) -> &'a mut W {
1019 {
1020 self.bit(variant._bits())
1021 }
1022 }
1023 #[doc = "exception is not active"]
1024 #[inline]
1025 pub fn _0(self) -> &'a mut W {
1026 self.variant(PENDSVACTW::_0)
1027 }
1028 #[doc = "exception is active"]
1029 #[inline]
1030 pub fn _1(self) -> &'a mut W {
1031 self.variant(PENDSVACTW::_1)
1032 }
1033 #[doc = r" Sets the field bit"]
1034 pub fn set_bit(self) -> &'a mut W {
1035 self.bit(true)
1036 }
1037 #[doc = r" Clears the field bit"]
1038 pub fn clear_bit(self) -> &'a mut W {
1039 self.bit(false)
1040 }
1041 #[doc = r" Writes raw bits to the field"]
1042 #[inline]
1043 pub fn bit(self, value: bool) -> &'a mut W {
1044 const MASK: bool = true;
1045 const OFFSET: u8 = 10;
1046 self.w.bits &= !((MASK as u32) << OFFSET);
1047 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1048 self.w
1049 }
1050}
1051#[doc = "Values that can be written to the field `SYSTICKACT`"]
1052pub enum SYSTICKACTW {
1053 #[doc = "exception is not active"]
1054 _0,
1055 #[doc = "exception is active"]
1056 _1,
1057}
1058impl SYSTICKACTW {
1059 #[allow(missing_docs)]
1060 #[doc(hidden)]
1061 #[inline]
1062 pub fn _bits(&self) -> bool {
1063 match *self {
1064 SYSTICKACTW::_0 => false,
1065 SYSTICKACTW::_1 => true,
1066 }
1067 }
1068}
1069#[doc = r" Proxy"]
1070pub struct _SYSTICKACTW<'a> {
1071 w: &'a mut W,
1072}
1073impl<'a> _SYSTICKACTW<'a> {
1074 #[doc = r" Writes `variant` to the field"]
1075 #[inline]
1076 pub fn variant(self, variant: SYSTICKACTW) -> &'a mut W {
1077 {
1078 self.bit(variant._bits())
1079 }
1080 }
1081 #[doc = "exception is not active"]
1082 #[inline]
1083 pub fn _0(self) -> &'a mut W {
1084 self.variant(SYSTICKACTW::_0)
1085 }
1086 #[doc = "exception is active"]
1087 #[inline]
1088 pub fn _1(self) -> &'a mut W {
1089 self.variant(SYSTICKACTW::_1)
1090 }
1091 #[doc = r" Sets the field bit"]
1092 pub fn set_bit(self) -> &'a mut W {
1093 self.bit(true)
1094 }
1095 #[doc = r" Clears the field bit"]
1096 pub fn clear_bit(self) -> &'a mut W {
1097 self.bit(false)
1098 }
1099 #[doc = r" Writes raw bits to the field"]
1100 #[inline]
1101 pub fn bit(self, value: bool) -> &'a mut W {
1102 const MASK: bool = true;
1103 const OFFSET: u8 = 11;
1104 self.w.bits &= !((MASK as u32) << OFFSET);
1105 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1106 self.w
1107 }
1108}
1109#[doc = "Values that can be written to the field `USGFAULTPENDED`"]
1110pub enum USGFAULTPENDEDW {
1111 #[doc = "exception is not pending"]
1112 _0,
1113 #[doc = "exception is pending"]
1114 _1,
1115}
1116impl USGFAULTPENDEDW {
1117 #[allow(missing_docs)]
1118 #[doc(hidden)]
1119 #[inline]
1120 pub fn _bits(&self) -> bool {
1121 match *self {
1122 USGFAULTPENDEDW::_0 => false,
1123 USGFAULTPENDEDW::_1 => true,
1124 }
1125 }
1126}
1127#[doc = r" Proxy"]
1128pub struct _USGFAULTPENDEDW<'a> {
1129 w: &'a mut W,
1130}
1131impl<'a> _USGFAULTPENDEDW<'a> {
1132 #[doc = r" Writes `variant` to the field"]
1133 #[inline]
1134 pub fn variant(self, variant: USGFAULTPENDEDW) -> &'a mut W {
1135 {
1136 self.bit(variant._bits())
1137 }
1138 }
1139 #[doc = "exception is not pending"]
1140 #[inline]
1141 pub fn _0(self) -> &'a mut W {
1142 self.variant(USGFAULTPENDEDW::_0)
1143 }
1144 #[doc = "exception is pending"]
1145 #[inline]
1146 pub fn _1(self) -> &'a mut W {
1147 self.variant(USGFAULTPENDEDW::_1)
1148 }
1149 #[doc = r" Sets the field bit"]
1150 pub fn set_bit(self) -> &'a mut W {
1151 self.bit(true)
1152 }
1153 #[doc = r" Clears the field bit"]
1154 pub fn clear_bit(self) -> &'a mut W {
1155 self.bit(false)
1156 }
1157 #[doc = r" Writes raw bits to the field"]
1158 #[inline]
1159 pub fn bit(self, value: bool) -> &'a mut W {
1160 const MASK: bool = true;
1161 const OFFSET: u8 = 12;
1162 self.w.bits &= !((MASK as u32) << OFFSET);
1163 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1164 self.w
1165 }
1166}
1167#[doc = "Values that can be written to the field `MEMFAULTPENDED`"]
1168pub enum MEMFAULTPENDEDW {
1169 #[doc = "exception is not pending"]
1170 _0,
1171 #[doc = "exception is pending"]
1172 _1,
1173}
1174impl MEMFAULTPENDEDW {
1175 #[allow(missing_docs)]
1176 #[doc(hidden)]
1177 #[inline]
1178 pub fn _bits(&self) -> bool {
1179 match *self {
1180 MEMFAULTPENDEDW::_0 => false,
1181 MEMFAULTPENDEDW::_1 => true,
1182 }
1183 }
1184}
1185#[doc = r" Proxy"]
1186pub struct _MEMFAULTPENDEDW<'a> {
1187 w: &'a mut W,
1188}
1189impl<'a> _MEMFAULTPENDEDW<'a> {
1190 #[doc = r" Writes `variant` to the field"]
1191 #[inline]
1192 pub fn variant(self, variant: MEMFAULTPENDEDW) -> &'a mut W {
1193 {
1194 self.bit(variant._bits())
1195 }
1196 }
1197 #[doc = "exception is not pending"]
1198 #[inline]
1199 pub fn _0(self) -> &'a mut W {
1200 self.variant(MEMFAULTPENDEDW::_0)
1201 }
1202 #[doc = "exception is pending"]
1203 #[inline]
1204 pub fn _1(self) -> &'a mut W {
1205 self.variant(MEMFAULTPENDEDW::_1)
1206 }
1207 #[doc = r" Sets the field bit"]
1208 pub fn set_bit(self) -> &'a mut W {
1209 self.bit(true)
1210 }
1211 #[doc = r" Clears the field bit"]
1212 pub fn clear_bit(self) -> &'a mut W {
1213 self.bit(false)
1214 }
1215 #[doc = r" Writes raw bits to the field"]
1216 #[inline]
1217 pub fn bit(self, value: bool) -> &'a mut W {
1218 const MASK: bool = true;
1219 const OFFSET: u8 = 13;
1220 self.w.bits &= !((MASK as u32) << OFFSET);
1221 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1222 self.w
1223 }
1224}
1225#[doc = "Values that can be written to the field `BUSFAULTPENDED`"]
1226pub enum BUSFAULTPENDEDW {
1227 #[doc = "exception is not pending"]
1228 _0,
1229 #[doc = "exception is pending"]
1230 _1,
1231}
1232impl BUSFAULTPENDEDW {
1233 #[allow(missing_docs)]
1234 #[doc(hidden)]
1235 #[inline]
1236 pub fn _bits(&self) -> bool {
1237 match *self {
1238 BUSFAULTPENDEDW::_0 => false,
1239 BUSFAULTPENDEDW::_1 => true,
1240 }
1241 }
1242}
1243#[doc = r" Proxy"]
1244pub struct _BUSFAULTPENDEDW<'a> {
1245 w: &'a mut W,
1246}
1247impl<'a> _BUSFAULTPENDEDW<'a> {
1248 #[doc = r" Writes `variant` to the field"]
1249 #[inline]
1250 pub fn variant(self, variant: BUSFAULTPENDEDW) -> &'a mut W {
1251 {
1252 self.bit(variant._bits())
1253 }
1254 }
1255 #[doc = "exception is not pending"]
1256 #[inline]
1257 pub fn _0(self) -> &'a mut W {
1258 self.variant(BUSFAULTPENDEDW::_0)
1259 }
1260 #[doc = "exception is pending"]
1261 #[inline]
1262 pub fn _1(self) -> &'a mut W {
1263 self.variant(BUSFAULTPENDEDW::_1)
1264 }
1265 #[doc = r" Sets the field bit"]
1266 pub fn set_bit(self) -> &'a mut W {
1267 self.bit(true)
1268 }
1269 #[doc = r" Clears the field bit"]
1270 pub fn clear_bit(self) -> &'a mut W {
1271 self.bit(false)
1272 }
1273 #[doc = r" Writes raw bits to the field"]
1274 #[inline]
1275 pub fn bit(self, value: bool) -> &'a mut W {
1276 const MASK: bool = true;
1277 const OFFSET: u8 = 14;
1278 self.w.bits &= !((MASK as u32) << OFFSET);
1279 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1280 self.w
1281 }
1282}
1283#[doc = "Values that can be written to the field `SVCALLPENDED`"]
1284pub enum SVCALLPENDEDW {
1285 #[doc = "exception is not pending"]
1286 _0,
1287 #[doc = "exception is pending"]
1288 _1,
1289}
1290impl SVCALLPENDEDW {
1291 #[allow(missing_docs)]
1292 #[doc(hidden)]
1293 #[inline]
1294 pub fn _bits(&self) -> bool {
1295 match *self {
1296 SVCALLPENDEDW::_0 => false,
1297 SVCALLPENDEDW::_1 => true,
1298 }
1299 }
1300}
1301#[doc = r" Proxy"]
1302pub struct _SVCALLPENDEDW<'a> {
1303 w: &'a mut W,
1304}
1305impl<'a> _SVCALLPENDEDW<'a> {
1306 #[doc = r" Writes `variant` to the field"]
1307 #[inline]
1308 pub fn variant(self, variant: SVCALLPENDEDW) -> &'a mut W {
1309 {
1310 self.bit(variant._bits())
1311 }
1312 }
1313 #[doc = "exception is not pending"]
1314 #[inline]
1315 pub fn _0(self) -> &'a mut W {
1316 self.variant(SVCALLPENDEDW::_0)
1317 }
1318 #[doc = "exception is pending"]
1319 #[inline]
1320 pub fn _1(self) -> &'a mut W {
1321 self.variant(SVCALLPENDEDW::_1)
1322 }
1323 #[doc = r" Sets the field bit"]
1324 pub fn set_bit(self) -> &'a mut W {
1325 self.bit(true)
1326 }
1327 #[doc = r" Clears the field bit"]
1328 pub fn clear_bit(self) -> &'a mut W {
1329 self.bit(false)
1330 }
1331 #[doc = r" Writes raw bits to the field"]
1332 #[inline]
1333 pub fn bit(self, value: bool) -> &'a mut W {
1334 const MASK: bool = true;
1335 const OFFSET: u8 = 15;
1336 self.w.bits &= !((MASK as u32) << OFFSET);
1337 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1338 self.w
1339 }
1340}
1341#[doc = "Values that can be written to the field `MEMFAULTENA`"]
1342pub enum MEMFAULTENAW {
1343 #[doc = "disable the exception"]
1344 _0,
1345 #[doc = "enable the exception"]
1346 _1,
1347}
1348impl MEMFAULTENAW {
1349 #[allow(missing_docs)]
1350 #[doc(hidden)]
1351 #[inline]
1352 pub fn _bits(&self) -> bool {
1353 match *self {
1354 MEMFAULTENAW::_0 => false,
1355 MEMFAULTENAW::_1 => true,
1356 }
1357 }
1358}
1359#[doc = r" Proxy"]
1360pub struct _MEMFAULTENAW<'a> {
1361 w: &'a mut W,
1362}
1363impl<'a> _MEMFAULTENAW<'a> {
1364 #[doc = r" Writes `variant` to the field"]
1365 #[inline]
1366 pub fn variant(self, variant: MEMFAULTENAW) -> &'a mut W {
1367 {
1368 self.bit(variant._bits())
1369 }
1370 }
1371 #[doc = "disable the exception"]
1372 #[inline]
1373 pub fn _0(self) -> &'a mut W {
1374 self.variant(MEMFAULTENAW::_0)
1375 }
1376 #[doc = "enable the exception"]
1377 #[inline]
1378 pub fn _1(self) -> &'a mut W {
1379 self.variant(MEMFAULTENAW::_1)
1380 }
1381 #[doc = r" Sets the field bit"]
1382 pub fn set_bit(self) -> &'a mut W {
1383 self.bit(true)
1384 }
1385 #[doc = r" Clears the field bit"]
1386 pub fn clear_bit(self) -> &'a mut W {
1387 self.bit(false)
1388 }
1389 #[doc = r" Writes raw bits to the field"]
1390 #[inline]
1391 pub fn bit(self, value: bool) -> &'a mut W {
1392 const MASK: bool = true;
1393 const OFFSET: u8 = 16;
1394 self.w.bits &= !((MASK as u32) << OFFSET);
1395 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1396 self.w
1397 }
1398}
1399#[doc = "Values that can be written to the field `BUSFAULTENA`"]
1400pub enum BUSFAULTENAW {
1401 #[doc = "disable the exception"]
1402 _0,
1403 #[doc = "enable the exception"]
1404 _1,
1405}
1406impl BUSFAULTENAW {
1407 #[allow(missing_docs)]
1408 #[doc(hidden)]
1409 #[inline]
1410 pub fn _bits(&self) -> bool {
1411 match *self {
1412 BUSFAULTENAW::_0 => false,
1413 BUSFAULTENAW::_1 => true,
1414 }
1415 }
1416}
1417#[doc = r" Proxy"]
1418pub struct _BUSFAULTENAW<'a> {
1419 w: &'a mut W,
1420}
1421impl<'a> _BUSFAULTENAW<'a> {
1422 #[doc = r" Writes `variant` to the field"]
1423 #[inline]
1424 pub fn variant(self, variant: BUSFAULTENAW) -> &'a mut W {
1425 {
1426 self.bit(variant._bits())
1427 }
1428 }
1429 #[doc = "disable the exception"]
1430 #[inline]
1431 pub fn _0(self) -> &'a mut W {
1432 self.variant(BUSFAULTENAW::_0)
1433 }
1434 #[doc = "enable the exception"]
1435 #[inline]
1436 pub fn _1(self) -> &'a mut W {
1437 self.variant(BUSFAULTENAW::_1)
1438 }
1439 #[doc = r" Sets the field bit"]
1440 pub fn set_bit(self) -> &'a mut W {
1441 self.bit(true)
1442 }
1443 #[doc = r" Clears the field bit"]
1444 pub fn clear_bit(self) -> &'a mut W {
1445 self.bit(false)
1446 }
1447 #[doc = r" Writes raw bits to the field"]
1448 #[inline]
1449 pub fn bit(self, value: bool) -> &'a mut W {
1450 const MASK: bool = true;
1451 const OFFSET: u8 = 17;
1452 self.w.bits &= !((MASK as u32) << OFFSET);
1453 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1454 self.w
1455 }
1456}
1457#[doc = "Values that can be written to the field `USGFAULTENA`"]
1458pub enum USGFAULTENAW {
1459 #[doc = "disable the exception"]
1460 _0,
1461 #[doc = "enable the exception"]
1462 _1,
1463}
1464impl USGFAULTENAW {
1465 #[allow(missing_docs)]
1466 #[doc(hidden)]
1467 #[inline]
1468 pub fn _bits(&self) -> bool {
1469 match *self {
1470 USGFAULTENAW::_0 => false,
1471 USGFAULTENAW::_1 => true,
1472 }
1473 }
1474}
1475#[doc = r" Proxy"]
1476pub struct _USGFAULTENAW<'a> {
1477 w: &'a mut W,
1478}
1479impl<'a> _USGFAULTENAW<'a> {
1480 #[doc = r" Writes `variant` to the field"]
1481 #[inline]
1482 pub fn variant(self, variant: USGFAULTENAW) -> &'a mut W {
1483 {
1484 self.bit(variant._bits())
1485 }
1486 }
1487 #[doc = "disable the exception"]
1488 #[inline]
1489 pub fn _0(self) -> &'a mut W {
1490 self.variant(USGFAULTENAW::_0)
1491 }
1492 #[doc = "enable the exception"]
1493 #[inline]
1494 pub fn _1(self) -> &'a mut W {
1495 self.variant(USGFAULTENAW::_1)
1496 }
1497 #[doc = r" Sets the field bit"]
1498 pub fn set_bit(self) -> &'a mut W {
1499 self.bit(true)
1500 }
1501 #[doc = r" Clears the field bit"]
1502 pub fn clear_bit(self) -> &'a mut W {
1503 self.bit(false)
1504 }
1505 #[doc = r" Writes raw bits to the field"]
1506 #[inline]
1507 pub fn bit(self, value: bool) -> &'a mut W {
1508 const MASK: bool = true;
1509 const OFFSET: u8 = 18;
1510 self.w.bits &= !((MASK as u32) << OFFSET);
1511 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1512 self.w
1513 }
1514}
1515impl R {
1516 #[doc = r" Value of the register as raw bits"]
1517 #[inline]
1518 pub fn bits(&self) -> u32 {
1519 self.bits
1520 }
1521 #[doc = "Bit 0 - no description available"]
1522 #[inline]
1523 pub fn memfaultact(&self) -> MEMFAULTACTR {
1524 MEMFAULTACTR::_from({
1525 const MASK: bool = true;
1526 const OFFSET: u8 = 0;
1527 ((self.bits >> OFFSET) & MASK as u32) != 0
1528 })
1529 }
1530 #[doc = "Bit 1 - no description available"]
1531 #[inline]
1532 pub fn busfaultact(&self) -> BUSFAULTACTR {
1533 BUSFAULTACTR::_from({
1534 const MASK: bool = true;
1535 const OFFSET: u8 = 1;
1536 ((self.bits >> OFFSET) & MASK as u32) != 0
1537 })
1538 }
1539 #[doc = "Bit 3 - no description available"]
1540 #[inline]
1541 pub fn usgfaultact(&self) -> USGFAULTACTR {
1542 USGFAULTACTR::_from({
1543 const MASK: bool = true;
1544 const OFFSET: u8 = 3;
1545 ((self.bits >> OFFSET) & MASK as u32) != 0
1546 })
1547 }
1548 #[doc = "Bit 7 - no description available"]
1549 #[inline]
1550 pub fn svcallact(&self) -> SVCALLACTR {
1551 SVCALLACTR::_from({
1552 const MASK: bool = true;
1553 const OFFSET: u8 = 7;
1554 ((self.bits >> OFFSET) & MASK as u32) != 0
1555 })
1556 }
1557 #[doc = "Bit 8 - no description available"]
1558 #[inline]
1559 pub fn monitoract(&self) -> MONITORACTR {
1560 MONITORACTR::_from({
1561 const MASK: bool = true;
1562 const OFFSET: u8 = 8;
1563 ((self.bits >> OFFSET) & MASK as u32) != 0
1564 })
1565 }
1566 #[doc = "Bit 10 - no description available"]
1567 #[inline]
1568 pub fn pendsvact(&self) -> PENDSVACTR {
1569 PENDSVACTR::_from({
1570 const MASK: bool = true;
1571 const OFFSET: u8 = 10;
1572 ((self.bits >> OFFSET) & MASK as u32) != 0
1573 })
1574 }
1575 #[doc = "Bit 11 - no description available"]
1576 #[inline]
1577 pub fn systickact(&self) -> SYSTICKACTR {
1578 SYSTICKACTR::_from({
1579 const MASK: bool = true;
1580 const OFFSET: u8 = 11;
1581 ((self.bits >> OFFSET) & MASK as u32) != 0
1582 })
1583 }
1584 #[doc = "Bit 12 - no description available"]
1585 #[inline]
1586 pub fn usgfaultpended(&self) -> USGFAULTPENDEDR {
1587 USGFAULTPENDEDR::_from({
1588 const MASK: bool = true;
1589 const OFFSET: u8 = 12;
1590 ((self.bits >> OFFSET) & MASK as u32) != 0
1591 })
1592 }
1593 #[doc = "Bit 13 - no description available"]
1594 #[inline]
1595 pub fn memfaultpended(&self) -> MEMFAULTPENDEDR {
1596 MEMFAULTPENDEDR::_from({
1597 const MASK: bool = true;
1598 const OFFSET: u8 = 13;
1599 ((self.bits >> OFFSET) & MASK as u32) != 0
1600 })
1601 }
1602 #[doc = "Bit 14 - no description available"]
1603 #[inline]
1604 pub fn busfaultpended(&self) -> BUSFAULTPENDEDR {
1605 BUSFAULTPENDEDR::_from({
1606 const MASK: bool = true;
1607 const OFFSET: u8 = 14;
1608 ((self.bits >> OFFSET) & MASK as u32) != 0
1609 })
1610 }
1611 #[doc = "Bit 15 - no description available"]
1612 #[inline]
1613 pub fn svcallpended(&self) -> SVCALLPENDEDR {
1614 SVCALLPENDEDR::_from({
1615 const MASK: bool = true;
1616 const OFFSET: u8 = 15;
1617 ((self.bits >> OFFSET) & MASK as u32) != 0
1618 })
1619 }
1620 #[doc = "Bit 16 - no description available"]
1621 #[inline]
1622 pub fn memfaultena(&self) -> MEMFAULTENAR {
1623 MEMFAULTENAR::_from({
1624 const MASK: bool = true;
1625 const OFFSET: u8 = 16;
1626 ((self.bits >> OFFSET) & MASK as u32) != 0
1627 })
1628 }
1629 #[doc = "Bit 17 - no description available"]
1630 #[inline]
1631 pub fn busfaultena(&self) -> BUSFAULTENAR {
1632 BUSFAULTENAR::_from({
1633 const MASK: bool = true;
1634 const OFFSET: u8 = 17;
1635 ((self.bits >> OFFSET) & MASK as u32) != 0
1636 })
1637 }
1638 #[doc = "Bit 18 - no description available"]
1639 #[inline]
1640 pub fn usgfaultena(&self) -> USGFAULTENAR {
1641 USGFAULTENAR::_from({
1642 const MASK: bool = true;
1643 const OFFSET: u8 = 18;
1644 ((self.bits >> OFFSET) & MASK as u32) != 0
1645 })
1646 }
1647}
1648impl W {
1649 #[doc = r" Reset value of the register"]
1650 #[inline]
1651 pub fn reset_value() -> W {
1652 W { bits: 0 }
1653 }
1654 #[doc = r" Writes raw bits to the register"]
1655 #[inline]
1656 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1657 self.bits = bits;
1658 self
1659 }
1660 #[doc = "Bit 0 - no description available"]
1661 #[inline]
1662 pub fn memfaultact(&mut self) -> _MEMFAULTACTW {
1663 _MEMFAULTACTW { w: self }
1664 }
1665 #[doc = "Bit 1 - no description available"]
1666 #[inline]
1667 pub fn busfaultact(&mut self) -> _BUSFAULTACTW {
1668 _BUSFAULTACTW { w: self }
1669 }
1670 #[doc = "Bit 3 - no description available"]
1671 #[inline]
1672 pub fn usgfaultact(&mut self) -> _USGFAULTACTW {
1673 _USGFAULTACTW { w: self }
1674 }
1675 #[doc = "Bit 7 - no description available"]
1676 #[inline]
1677 pub fn svcallact(&mut self) -> _SVCALLACTW {
1678 _SVCALLACTW { w: self }
1679 }
1680 #[doc = "Bit 8 - no description available"]
1681 #[inline]
1682 pub fn monitoract(&mut self) -> _MONITORACTW {
1683 _MONITORACTW { w: self }
1684 }
1685 #[doc = "Bit 10 - no description available"]
1686 #[inline]
1687 pub fn pendsvact(&mut self) -> _PENDSVACTW {
1688 _PENDSVACTW { w: self }
1689 }
1690 #[doc = "Bit 11 - no description available"]
1691 #[inline]
1692 pub fn systickact(&mut self) -> _SYSTICKACTW {
1693 _SYSTICKACTW { w: self }
1694 }
1695 #[doc = "Bit 12 - no description available"]
1696 #[inline]
1697 pub fn usgfaultpended(&mut self) -> _USGFAULTPENDEDW {
1698 _USGFAULTPENDEDW { w: self }
1699 }
1700 #[doc = "Bit 13 - no description available"]
1701 #[inline]
1702 pub fn memfaultpended(&mut self) -> _MEMFAULTPENDEDW {
1703 _MEMFAULTPENDEDW { w: self }
1704 }
1705 #[doc = "Bit 14 - no description available"]
1706 #[inline]
1707 pub fn busfaultpended(&mut self) -> _BUSFAULTPENDEDW {
1708 _BUSFAULTPENDEDW { w: self }
1709 }
1710 #[doc = "Bit 15 - no description available"]
1711 #[inline]
1712 pub fn svcallpended(&mut self) -> _SVCALLPENDEDW {
1713 _SVCALLPENDEDW { w: self }
1714 }
1715 #[doc = "Bit 16 - no description available"]
1716 #[inline]
1717 pub fn memfaultena(&mut self) -> _MEMFAULTENAW {
1718 _MEMFAULTENAW { w: self }
1719 }
1720 #[doc = "Bit 17 - no description available"]
1721 #[inline]
1722 pub fn busfaultena(&mut self) -> _BUSFAULTENAW {
1723 _BUSFAULTENAW { w: self }
1724 }
1725 #[doc = "Bit 18 - no description available"]
1726 #[inline]
1727 pub fn usgfaultena(&mut self) -> _USGFAULTENAW {
1728 _USGFAULTENAW { w: self }
1729 }
1730}