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::REGIONEN {
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 `RGN0WA`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum RGN0WAR {
48 #[doc = "Disable write access watch in this region"]
49 DISABLE,
50 #[doc = "Enable write access watch in this region"]
51 ENABLE,
52}
53impl RGN0WAR {
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 RGN0WAR::DISABLE => false,
69 RGN0WAR::ENABLE => true,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> RGN0WAR {
76 match value {
77 false => RGN0WAR::DISABLE,
78 true => RGN0WAR::ENABLE,
79 }
80 }
81 #[doc = "Checks if the value of the field is `DISABLE`"]
82 #[inline]
83 pub fn is_disable(&self) -> bool {
84 *self == RGN0WAR::DISABLE
85 }
86 #[doc = "Checks if the value of the field is `ENABLE`"]
87 #[inline]
88 pub fn is_enable(&self) -> bool {
89 *self == RGN0WAR::ENABLE
90 }
91}
92#[doc = "Possible values of the field `RGN0RA`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum RGN0RAR {
95 #[doc = "Disable read access watch in this region"]
96 DISABLE,
97 #[doc = "Enable read access watch in this region"]
98 ENABLE,
99}
100impl RGN0RAR {
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 RGN0RAR::DISABLE => false,
116 RGN0RAR::ENABLE => true,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> RGN0RAR {
123 match value {
124 false => RGN0RAR::DISABLE,
125 true => RGN0RAR::ENABLE,
126 }
127 }
128 #[doc = "Checks if the value of the field is `DISABLE`"]
129 #[inline]
130 pub fn is_disable(&self) -> bool {
131 *self == RGN0RAR::DISABLE
132 }
133 #[doc = "Checks if the value of the field is `ENABLE`"]
134 #[inline]
135 pub fn is_enable(&self) -> bool {
136 *self == RGN0RAR::ENABLE
137 }
138}
139#[doc = "Possible values of the field `RGN1WA`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum RGN1WAR {
142 #[doc = "Disable write access watch in this region"]
143 DISABLE,
144 #[doc = "Enable write access watch in this region"]
145 ENABLE,
146}
147impl RGN1WAR {
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 RGN1WAR::DISABLE => false,
163 RGN1WAR::ENABLE => true,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> RGN1WAR {
170 match value {
171 false => RGN1WAR::DISABLE,
172 true => RGN1WAR::ENABLE,
173 }
174 }
175 #[doc = "Checks if the value of the field is `DISABLE`"]
176 #[inline]
177 pub fn is_disable(&self) -> bool {
178 *self == RGN1WAR::DISABLE
179 }
180 #[doc = "Checks if the value of the field is `ENABLE`"]
181 #[inline]
182 pub fn is_enable(&self) -> bool {
183 *self == RGN1WAR::ENABLE
184 }
185}
186#[doc = "Possible values of the field `RGN1RA`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum RGN1RAR {
189 #[doc = "Disable read access watch in this region"]
190 DISABLE,
191 #[doc = "Enable read access watch in this region"]
192 ENABLE,
193}
194impl RGN1RAR {
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 RGN1RAR::DISABLE => false,
210 RGN1RAR::ENABLE => true,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> RGN1RAR {
217 match value {
218 false => RGN1RAR::DISABLE,
219 true => RGN1RAR::ENABLE,
220 }
221 }
222 #[doc = "Checks if the value of the field is `DISABLE`"]
223 #[inline]
224 pub fn is_disable(&self) -> bool {
225 *self == RGN1RAR::DISABLE
226 }
227 #[doc = "Checks if the value of the field is `ENABLE`"]
228 #[inline]
229 pub fn is_enable(&self) -> bool {
230 *self == RGN1RAR::ENABLE
231 }
232}
233#[doc = "Possible values of the field `RGN2WA`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum RGN2WAR {
236 #[doc = "Disable write access watch in this region"]
237 DISABLE,
238 #[doc = "Enable write access watch in this region"]
239 ENABLE,
240}
241impl RGN2WAR {
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 RGN2WAR::DISABLE => false,
257 RGN2WAR::ENABLE => true,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> RGN2WAR {
264 match value {
265 false => RGN2WAR::DISABLE,
266 true => RGN2WAR::ENABLE,
267 }
268 }
269 #[doc = "Checks if the value of the field is `DISABLE`"]
270 #[inline]
271 pub fn is_disable(&self) -> bool {
272 *self == RGN2WAR::DISABLE
273 }
274 #[doc = "Checks if the value of the field is `ENABLE`"]
275 #[inline]
276 pub fn is_enable(&self) -> bool {
277 *self == RGN2WAR::ENABLE
278 }
279}
280#[doc = "Possible values of the field `RGN2RA`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum RGN2RAR {
283 #[doc = "Disable read access watch in this region"]
284 DISABLE,
285 #[doc = "Enable read access watch in this region"]
286 ENABLE,
287}
288impl RGN2RAR {
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 RGN2RAR::DISABLE => false,
304 RGN2RAR::ENABLE => true,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> RGN2RAR {
311 match value {
312 false => RGN2RAR::DISABLE,
313 true => RGN2RAR::ENABLE,
314 }
315 }
316 #[doc = "Checks if the value of the field is `DISABLE`"]
317 #[inline]
318 pub fn is_disable(&self) -> bool {
319 *self == RGN2RAR::DISABLE
320 }
321 #[doc = "Checks if the value of the field is `ENABLE`"]
322 #[inline]
323 pub fn is_enable(&self) -> bool {
324 *self == RGN2RAR::ENABLE
325 }
326}
327#[doc = "Possible values of the field `RGN3WA`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum RGN3WAR {
330 #[doc = "Disable write access watch in this region"]
331 DISABLE,
332 #[doc = "Enable write access watch in this region"]
333 ENABLE,
334}
335impl RGN3WAR {
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 RGN3WAR::DISABLE => false,
351 RGN3WAR::ENABLE => true,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> RGN3WAR {
358 match value {
359 false => RGN3WAR::DISABLE,
360 true => RGN3WAR::ENABLE,
361 }
362 }
363 #[doc = "Checks if the value of the field is `DISABLE`"]
364 #[inline]
365 pub fn is_disable(&self) -> bool {
366 *self == RGN3WAR::DISABLE
367 }
368 #[doc = "Checks if the value of the field is `ENABLE`"]
369 #[inline]
370 pub fn is_enable(&self) -> bool {
371 *self == RGN3WAR::ENABLE
372 }
373}
374#[doc = "Possible values of the field `RGN3RA`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum RGN3RAR {
377 #[doc = "Disable read access watch in this region"]
378 DISABLE,
379 #[doc = "Enable read access watch in this region"]
380 ENABLE,
381}
382impl RGN3RAR {
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 RGN3RAR::DISABLE => false,
398 RGN3RAR::ENABLE => true,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> RGN3RAR {
405 match value {
406 false => RGN3RAR::DISABLE,
407 true => RGN3RAR::ENABLE,
408 }
409 }
410 #[doc = "Checks if the value of the field is `DISABLE`"]
411 #[inline]
412 pub fn is_disable(&self) -> bool {
413 *self == RGN3RAR::DISABLE
414 }
415 #[doc = "Checks if the value of the field is `ENABLE`"]
416 #[inline]
417 pub fn is_enable(&self) -> bool {
418 *self == RGN3RAR::ENABLE
419 }
420}
421#[doc = "Possible values of the field `PRGN0WA`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum PRGN0WAR {
424 #[doc = "Disable write access watch in this PREGION"]
425 DISABLE,
426 #[doc = "Enable write access watch in this PREGION"]
427 ENABLE,
428}
429impl PRGN0WAR {
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 PRGN0WAR::DISABLE => false,
445 PRGN0WAR::ENABLE => true,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> PRGN0WAR {
452 match value {
453 false => PRGN0WAR::DISABLE,
454 true => PRGN0WAR::ENABLE,
455 }
456 }
457 #[doc = "Checks if the value of the field is `DISABLE`"]
458 #[inline]
459 pub fn is_disable(&self) -> bool {
460 *self == PRGN0WAR::DISABLE
461 }
462 #[doc = "Checks if the value of the field is `ENABLE`"]
463 #[inline]
464 pub fn is_enable(&self) -> bool {
465 *self == PRGN0WAR::ENABLE
466 }
467}
468#[doc = "Possible values of the field `PRGN0RA`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum PRGN0RAR {
471 #[doc = "Disable read access watch in this PREGION"]
472 DISABLE,
473 #[doc = "Enable read access watch in this PREGION"]
474 ENABLE,
475}
476impl PRGN0RAR {
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 PRGN0RAR::DISABLE => false,
492 PRGN0RAR::ENABLE => true,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> PRGN0RAR {
499 match value {
500 false => PRGN0RAR::DISABLE,
501 true => PRGN0RAR::ENABLE,
502 }
503 }
504 #[doc = "Checks if the value of the field is `DISABLE`"]
505 #[inline]
506 pub fn is_disable(&self) -> bool {
507 *self == PRGN0RAR::DISABLE
508 }
509 #[doc = "Checks if the value of the field is `ENABLE`"]
510 #[inline]
511 pub fn is_enable(&self) -> bool {
512 *self == PRGN0RAR::ENABLE
513 }
514}
515#[doc = "Possible values of the field `PRGN1WA`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum PRGN1WAR {
518 #[doc = "Disable write access watch in this PREGION"]
519 DISABLE,
520 #[doc = "Enable write access watch in this PREGION"]
521 ENABLE,
522}
523impl PRGN1WAR {
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 PRGN1WAR::DISABLE => false,
539 PRGN1WAR::ENABLE => true,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> PRGN1WAR {
546 match value {
547 false => PRGN1WAR::DISABLE,
548 true => PRGN1WAR::ENABLE,
549 }
550 }
551 #[doc = "Checks if the value of the field is `DISABLE`"]
552 #[inline]
553 pub fn is_disable(&self) -> bool {
554 *self == PRGN1WAR::DISABLE
555 }
556 #[doc = "Checks if the value of the field is `ENABLE`"]
557 #[inline]
558 pub fn is_enable(&self) -> bool {
559 *self == PRGN1WAR::ENABLE
560 }
561}
562#[doc = "Possible values of the field `PRGN1RA`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum PRGN1RAR {
565 #[doc = "Disable read access watch in this PREGION"]
566 DISABLE,
567 #[doc = "Enable read access watch in this PREGION"]
568 ENABLE,
569}
570impl PRGN1RAR {
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 PRGN1RAR::DISABLE => false,
586 PRGN1RAR::ENABLE => true,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> PRGN1RAR {
593 match value {
594 false => PRGN1RAR::DISABLE,
595 true => PRGN1RAR::ENABLE,
596 }
597 }
598 #[doc = "Checks if the value of the field is `DISABLE`"]
599 #[inline]
600 pub fn is_disable(&self) -> bool {
601 *self == PRGN1RAR::DISABLE
602 }
603 #[doc = "Checks if the value of the field is `ENABLE`"]
604 #[inline]
605 pub fn is_enable(&self) -> bool {
606 *self == PRGN1RAR::ENABLE
607 }
608}
609#[doc = "Values that can be written to the field `RGN0WA`"]
610pub enum RGN0WAW {
611 #[doc = "Disable write access watch in this region"]
612 DISABLE,
613 #[doc = "Enable write access watch in this region"]
614 ENABLE,
615}
616impl RGN0WAW {
617 #[allow(missing_docs)]
618 #[doc(hidden)]
619 #[inline]
620 pub fn _bits(&self) -> bool {
621 match *self {
622 RGN0WAW::DISABLE => false,
623 RGN0WAW::ENABLE => true,
624 }
625 }
626}
627#[doc = r" Proxy"]
628pub struct _RGN0WAW<'a> {
629 w: &'a mut W,
630}
631impl<'a> _RGN0WAW<'a> {
632 #[doc = r" Writes `variant` to the field"]
633 #[inline]
634 pub fn variant(self, variant: RGN0WAW) -> &'a mut W {
635 {
636 self.bit(variant._bits())
637 }
638 }
639 #[doc = "Disable write access watch in this region"]
640 #[inline]
641 pub fn disable(self) -> &'a mut W {
642 self.variant(RGN0WAW::DISABLE)
643 }
644 #[doc = "Enable write access watch in this region"]
645 #[inline]
646 pub fn enable(self) -> &'a mut W {
647 self.variant(RGN0WAW::ENABLE)
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 `RGN0RA`"]
668pub enum RGN0RAW {
669 #[doc = "Disable read access watch in this region"]
670 DISABLE,
671 #[doc = "Enable read access watch in this region"]
672 ENABLE,
673}
674impl RGN0RAW {
675 #[allow(missing_docs)]
676 #[doc(hidden)]
677 #[inline]
678 pub fn _bits(&self) -> bool {
679 match *self {
680 RGN0RAW::DISABLE => false,
681 RGN0RAW::ENABLE => true,
682 }
683 }
684}
685#[doc = r" Proxy"]
686pub struct _RGN0RAW<'a> {
687 w: &'a mut W,
688}
689impl<'a> _RGN0RAW<'a> {
690 #[doc = r" Writes `variant` to the field"]
691 #[inline]
692 pub fn variant(self, variant: RGN0RAW) -> &'a mut W {
693 {
694 self.bit(variant._bits())
695 }
696 }
697 #[doc = "Disable read access watch in this region"]
698 #[inline]
699 pub fn disable(self) -> &'a mut W {
700 self.variant(RGN0RAW::DISABLE)
701 }
702 #[doc = "Enable read access watch in this region"]
703 #[inline]
704 pub fn enable(self) -> &'a mut W {
705 self.variant(RGN0RAW::ENABLE)
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 `RGN1WA`"]
726pub enum RGN1WAW {
727 #[doc = "Disable write access watch in this region"]
728 DISABLE,
729 #[doc = "Enable write access watch in this region"]
730 ENABLE,
731}
732impl RGN1WAW {
733 #[allow(missing_docs)]
734 #[doc(hidden)]
735 #[inline]
736 pub fn _bits(&self) -> bool {
737 match *self {
738 RGN1WAW::DISABLE => false,
739 RGN1WAW::ENABLE => true,
740 }
741 }
742}
743#[doc = r" Proxy"]
744pub struct _RGN1WAW<'a> {
745 w: &'a mut W,
746}
747impl<'a> _RGN1WAW<'a> {
748 #[doc = r" Writes `variant` to the field"]
749 #[inline]
750 pub fn variant(self, variant: RGN1WAW) -> &'a mut W {
751 {
752 self.bit(variant._bits())
753 }
754 }
755 #[doc = "Disable write access watch in this region"]
756 #[inline]
757 pub fn disable(self) -> &'a mut W {
758 self.variant(RGN1WAW::DISABLE)
759 }
760 #[doc = "Enable write access watch in this region"]
761 #[inline]
762 pub fn enable(self) -> &'a mut W {
763 self.variant(RGN1WAW::ENABLE)
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 `RGN1RA`"]
784pub enum RGN1RAW {
785 #[doc = "Disable read access watch in this region"]
786 DISABLE,
787 #[doc = "Enable read access watch in this region"]
788 ENABLE,
789}
790impl RGN1RAW {
791 #[allow(missing_docs)]
792 #[doc(hidden)]
793 #[inline]
794 pub fn _bits(&self) -> bool {
795 match *self {
796 RGN1RAW::DISABLE => false,
797 RGN1RAW::ENABLE => true,
798 }
799 }
800}
801#[doc = r" Proxy"]
802pub struct _RGN1RAW<'a> {
803 w: &'a mut W,
804}
805impl<'a> _RGN1RAW<'a> {
806 #[doc = r" Writes `variant` to the field"]
807 #[inline]
808 pub fn variant(self, variant: RGN1RAW) -> &'a mut W {
809 {
810 self.bit(variant._bits())
811 }
812 }
813 #[doc = "Disable read access watch in this region"]
814 #[inline]
815 pub fn disable(self) -> &'a mut W {
816 self.variant(RGN1RAW::DISABLE)
817 }
818 #[doc = "Enable read access watch in this region"]
819 #[inline]
820 pub fn enable(self) -> &'a mut W {
821 self.variant(RGN1RAW::ENABLE)
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 `RGN2WA`"]
842pub enum RGN2WAW {
843 #[doc = "Disable write access watch in this region"]
844 DISABLE,
845 #[doc = "Enable write access watch in this region"]
846 ENABLE,
847}
848impl RGN2WAW {
849 #[allow(missing_docs)]
850 #[doc(hidden)]
851 #[inline]
852 pub fn _bits(&self) -> bool {
853 match *self {
854 RGN2WAW::DISABLE => false,
855 RGN2WAW::ENABLE => true,
856 }
857 }
858}
859#[doc = r" Proxy"]
860pub struct _RGN2WAW<'a> {
861 w: &'a mut W,
862}
863impl<'a> _RGN2WAW<'a> {
864 #[doc = r" Writes `variant` to the field"]
865 #[inline]
866 pub fn variant(self, variant: RGN2WAW) -> &'a mut W {
867 {
868 self.bit(variant._bits())
869 }
870 }
871 #[doc = "Disable write access watch in this region"]
872 #[inline]
873 pub fn disable(self) -> &'a mut W {
874 self.variant(RGN2WAW::DISABLE)
875 }
876 #[doc = "Enable write access watch in this region"]
877 #[inline]
878 pub fn enable(self) -> &'a mut W {
879 self.variant(RGN2WAW::ENABLE)
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 `RGN2RA`"]
900pub enum RGN2RAW {
901 #[doc = "Disable read access watch in this region"]
902 DISABLE,
903 #[doc = "Enable read access watch in this region"]
904 ENABLE,
905}
906impl RGN2RAW {
907 #[allow(missing_docs)]
908 #[doc(hidden)]
909 #[inline]
910 pub fn _bits(&self) -> bool {
911 match *self {
912 RGN2RAW::DISABLE => false,
913 RGN2RAW::ENABLE => true,
914 }
915 }
916}
917#[doc = r" Proxy"]
918pub struct _RGN2RAW<'a> {
919 w: &'a mut W,
920}
921impl<'a> _RGN2RAW<'a> {
922 #[doc = r" Writes `variant` to the field"]
923 #[inline]
924 pub fn variant(self, variant: RGN2RAW) -> &'a mut W {
925 {
926 self.bit(variant._bits())
927 }
928 }
929 #[doc = "Disable read access watch in this region"]
930 #[inline]
931 pub fn disable(self) -> &'a mut W {
932 self.variant(RGN2RAW::DISABLE)
933 }
934 #[doc = "Enable read access watch in this region"]
935 #[inline]
936 pub fn enable(self) -> &'a mut W {
937 self.variant(RGN2RAW::ENABLE)
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 `RGN3WA`"]
958pub enum RGN3WAW {
959 #[doc = "Disable write access watch in this region"]
960 DISABLE,
961 #[doc = "Enable write access watch in this region"]
962 ENABLE,
963}
964impl RGN3WAW {
965 #[allow(missing_docs)]
966 #[doc(hidden)]
967 #[inline]
968 pub fn _bits(&self) -> bool {
969 match *self {
970 RGN3WAW::DISABLE => false,
971 RGN3WAW::ENABLE => true,
972 }
973 }
974}
975#[doc = r" Proxy"]
976pub struct _RGN3WAW<'a> {
977 w: &'a mut W,
978}
979impl<'a> _RGN3WAW<'a> {
980 #[doc = r" Writes `variant` to the field"]
981 #[inline]
982 pub fn variant(self, variant: RGN3WAW) -> &'a mut W {
983 {
984 self.bit(variant._bits())
985 }
986 }
987 #[doc = "Disable write access watch in this region"]
988 #[inline]
989 pub fn disable(self) -> &'a mut W {
990 self.variant(RGN3WAW::DISABLE)
991 }
992 #[doc = "Enable write access watch in this region"]
993 #[inline]
994 pub fn enable(self) -> &'a mut W {
995 self.variant(RGN3WAW::ENABLE)
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 `RGN3RA`"]
1016pub enum RGN3RAW {
1017 #[doc = "Disable read access watch in this region"]
1018 DISABLE,
1019 #[doc = "Enable read access watch in this region"]
1020 ENABLE,
1021}
1022impl RGN3RAW {
1023 #[allow(missing_docs)]
1024 #[doc(hidden)]
1025 #[inline]
1026 pub fn _bits(&self) -> bool {
1027 match *self {
1028 RGN3RAW::DISABLE => false,
1029 RGN3RAW::ENABLE => true,
1030 }
1031 }
1032}
1033#[doc = r" Proxy"]
1034pub struct _RGN3RAW<'a> {
1035 w: &'a mut W,
1036}
1037impl<'a> _RGN3RAW<'a> {
1038 #[doc = r" Writes `variant` to the field"]
1039 #[inline]
1040 pub fn variant(self, variant: RGN3RAW) -> &'a mut W {
1041 {
1042 self.bit(variant._bits())
1043 }
1044 }
1045 #[doc = "Disable read access watch in this region"]
1046 #[inline]
1047 pub fn disable(self) -> &'a mut W {
1048 self.variant(RGN3RAW::DISABLE)
1049 }
1050 #[doc = "Enable read access watch in this region"]
1051 #[inline]
1052 pub fn enable(self) -> &'a mut W {
1053 self.variant(RGN3RAW::ENABLE)
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 `PRGN0WA`"]
1074pub enum PRGN0WAW {
1075 #[doc = "Disable write access watch in this PREGION"]
1076 DISABLE,
1077 #[doc = "Enable write access watch in this PREGION"]
1078 ENABLE,
1079}
1080impl PRGN0WAW {
1081 #[allow(missing_docs)]
1082 #[doc(hidden)]
1083 #[inline]
1084 pub fn _bits(&self) -> bool {
1085 match *self {
1086 PRGN0WAW::DISABLE => false,
1087 PRGN0WAW::ENABLE => true,
1088 }
1089 }
1090}
1091#[doc = r" Proxy"]
1092pub struct _PRGN0WAW<'a> {
1093 w: &'a mut W,
1094}
1095impl<'a> _PRGN0WAW<'a> {
1096 #[doc = r" Writes `variant` to the field"]
1097 #[inline]
1098 pub fn variant(self, variant: PRGN0WAW) -> &'a mut W {
1099 {
1100 self.bit(variant._bits())
1101 }
1102 }
1103 #[doc = "Disable write access watch in this PREGION"]
1104 #[inline]
1105 pub fn disable(self) -> &'a mut W {
1106 self.variant(PRGN0WAW::DISABLE)
1107 }
1108 #[doc = "Enable write access watch in this PREGION"]
1109 #[inline]
1110 pub fn enable(self) -> &'a mut W {
1111 self.variant(PRGN0WAW::ENABLE)
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 = 24;
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 `PRGN0RA`"]
1132pub enum PRGN0RAW {
1133 #[doc = "Disable read access watch in this PREGION"]
1134 DISABLE,
1135 #[doc = "Enable read access watch in this PREGION"]
1136 ENABLE,
1137}
1138impl PRGN0RAW {
1139 #[allow(missing_docs)]
1140 #[doc(hidden)]
1141 #[inline]
1142 pub fn _bits(&self) -> bool {
1143 match *self {
1144 PRGN0RAW::DISABLE => false,
1145 PRGN0RAW::ENABLE => true,
1146 }
1147 }
1148}
1149#[doc = r" Proxy"]
1150pub struct _PRGN0RAW<'a> {
1151 w: &'a mut W,
1152}
1153impl<'a> _PRGN0RAW<'a> {
1154 #[doc = r" Writes `variant` to the field"]
1155 #[inline]
1156 pub fn variant(self, variant: PRGN0RAW) -> &'a mut W {
1157 {
1158 self.bit(variant._bits())
1159 }
1160 }
1161 #[doc = "Disable read access watch in this PREGION"]
1162 #[inline]
1163 pub fn disable(self) -> &'a mut W {
1164 self.variant(PRGN0RAW::DISABLE)
1165 }
1166 #[doc = "Enable read access watch in this PREGION"]
1167 #[inline]
1168 pub fn enable(self) -> &'a mut W {
1169 self.variant(PRGN0RAW::ENABLE)
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 = 25;
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 `PRGN1WA`"]
1190pub enum PRGN1WAW {
1191 #[doc = "Disable write access watch in this PREGION"]
1192 DISABLE,
1193 #[doc = "Enable write access watch in this PREGION"]
1194 ENABLE,
1195}
1196impl PRGN1WAW {
1197 #[allow(missing_docs)]
1198 #[doc(hidden)]
1199 #[inline]
1200 pub fn _bits(&self) -> bool {
1201 match *self {
1202 PRGN1WAW::DISABLE => false,
1203 PRGN1WAW::ENABLE => true,
1204 }
1205 }
1206}
1207#[doc = r" Proxy"]
1208pub struct _PRGN1WAW<'a> {
1209 w: &'a mut W,
1210}
1211impl<'a> _PRGN1WAW<'a> {
1212 #[doc = r" Writes `variant` to the field"]
1213 #[inline]
1214 pub fn variant(self, variant: PRGN1WAW) -> &'a mut W {
1215 {
1216 self.bit(variant._bits())
1217 }
1218 }
1219 #[doc = "Disable write access watch in this PREGION"]
1220 #[inline]
1221 pub fn disable(self) -> &'a mut W {
1222 self.variant(PRGN1WAW::DISABLE)
1223 }
1224 #[doc = "Enable write access watch in this PREGION"]
1225 #[inline]
1226 pub fn enable(self) -> &'a mut W {
1227 self.variant(PRGN1WAW::ENABLE)
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 = 26;
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 `PRGN1RA`"]
1248pub enum PRGN1RAW {
1249 #[doc = "Disable read access watch in this PREGION"]
1250 DISABLE,
1251 #[doc = "Enable read access watch in this PREGION"]
1252 ENABLE,
1253}
1254impl PRGN1RAW {
1255 #[allow(missing_docs)]
1256 #[doc(hidden)]
1257 #[inline]
1258 pub fn _bits(&self) -> bool {
1259 match *self {
1260 PRGN1RAW::DISABLE => false,
1261 PRGN1RAW::ENABLE => true,
1262 }
1263 }
1264}
1265#[doc = r" Proxy"]
1266pub struct _PRGN1RAW<'a> {
1267 w: &'a mut W,
1268}
1269impl<'a> _PRGN1RAW<'a> {
1270 #[doc = r" Writes `variant` to the field"]
1271 #[inline]
1272 pub fn variant(self, variant: PRGN1RAW) -> &'a mut W {
1273 {
1274 self.bit(variant._bits())
1275 }
1276 }
1277 #[doc = "Disable read access watch in this PREGION"]
1278 #[inline]
1279 pub fn disable(self) -> &'a mut W {
1280 self.variant(PRGN1RAW::DISABLE)
1281 }
1282 #[doc = "Enable read access watch in this PREGION"]
1283 #[inline]
1284 pub fn enable(self) -> &'a mut W {
1285 self.variant(PRGN1RAW::ENABLE)
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 = 27;
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 - Enable/disable write access watch in region[0]"]
1312 #[inline]
1313 pub fn rgn0wa(&self) -> RGN0WAR {
1314 RGN0WAR::_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 - Enable/disable read access watch in region[0]"]
1321 #[inline]
1322 pub fn rgn0ra(&self) -> RGN0RAR {
1323 RGN0RAR::_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 - Enable/disable write access watch in region[1]"]
1330 #[inline]
1331 pub fn rgn1wa(&self) -> RGN1WAR {
1332 RGN1WAR::_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 - Enable/disable read access watch in region[1]"]
1339 #[inline]
1340 pub fn rgn1ra(&self) -> RGN1RAR {
1341 RGN1RAR::_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 - Enable/disable write access watch in region[2]"]
1348 #[inline]
1349 pub fn rgn2wa(&self) -> RGN2WAR {
1350 RGN2WAR::_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 - Enable/disable read access watch in region[2]"]
1357 #[inline]
1358 pub fn rgn2ra(&self) -> RGN2RAR {
1359 RGN2RAR::_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 - Enable/disable write access watch in region[3]"]
1366 #[inline]
1367 pub fn rgn3wa(&self) -> RGN3WAR {
1368 RGN3WAR::_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 - Enable/disable read access watch in region[3]"]
1375 #[inline]
1376 pub fn rgn3ra(&self) -> RGN3RAR {
1377 RGN3RAR::_from({
1378 const MASK: bool = true;
1379 const OFFSET: u8 = 7;
1380 ((self.bits >> OFFSET) & MASK as u32) != 0
1381 })
1382 }
1383 #[doc = "Bit 24 - Enable/disable write access watch in PREGION[0]"]
1384 #[inline]
1385 pub fn prgn0wa(&self) -> PRGN0WAR {
1386 PRGN0WAR::_from({
1387 const MASK: bool = true;
1388 const OFFSET: u8 = 24;
1389 ((self.bits >> OFFSET) & MASK as u32) != 0
1390 })
1391 }
1392 #[doc = "Bit 25 - Enable/disable read access watch in PREGION[0]"]
1393 #[inline]
1394 pub fn prgn0ra(&self) -> PRGN0RAR {
1395 PRGN0RAR::_from({
1396 const MASK: bool = true;
1397 const OFFSET: u8 = 25;
1398 ((self.bits >> OFFSET) & MASK as u32) != 0
1399 })
1400 }
1401 #[doc = "Bit 26 - Enable/disable write access watch in PREGION[1]"]
1402 #[inline]
1403 pub fn prgn1wa(&self) -> PRGN1WAR {
1404 PRGN1WAR::_from({
1405 const MASK: bool = true;
1406 const OFFSET: u8 = 26;
1407 ((self.bits >> OFFSET) & MASK as u32) != 0
1408 })
1409 }
1410 #[doc = "Bit 27 - Enable/disable read access watch in PREGION[1]"]
1411 #[inline]
1412 pub fn prgn1ra(&self) -> PRGN1RAR {
1413 PRGN1RAR::_from({
1414 const MASK: bool = true;
1415 const OFFSET: u8 = 27;
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 - Enable/disable write access watch in region[0]"]
1433 #[inline]
1434 pub fn rgn0wa(&mut self) -> _RGN0WAW {
1435 _RGN0WAW { w: self }
1436 }
1437 #[doc = "Bit 1 - Enable/disable read access watch in region[0]"]
1438 #[inline]
1439 pub fn rgn0ra(&mut self) -> _RGN0RAW {
1440 _RGN0RAW { w: self }
1441 }
1442 #[doc = "Bit 2 - Enable/disable write access watch in region[1]"]
1443 #[inline]
1444 pub fn rgn1wa(&mut self) -> _RGN1WAW {
1445 _RGN1WAW { w: self }
1446 }
1447 #[doc = "Bit 3 - Enable/disable read access watch in region[1]"]
1448 #[inline]
1449 pub fn rgn1ra(&mut self) -> _RGN1RAW {
1450 _RGN1RAW { w: self }
1451 }
1452 #[doc = "Bit 4 - Enable/disable write access watch in region[2]"]
1453 #[inline]
1454 pub fn rgn2wa(&mut self) -> _RGN2WAW {
1455 _RGN2WAW { w: self }
1456 }
1457 #[doc = "Bit 5 - Enable/disable read access watch in region[2]"]
1458 #[inline]
1459 pub fn rgn2ra(&mut self) -> _RGN2RAW {
1460 _RGN2RAW { w: self }
1461 }
1462 #[doc = "Bit 6 - Enable/disable write access watch in region[3]"]
1463 #[inline]
1464 pub fn rgn3wa(&mut self) -> _RGN3WAW {
1465 _RGN3WAW { w: self }
1466 }
1467 #[doc = "Bit 7 - Enable/disable read access watch in region[3]"]
1468 #[inline]
1469 pub fn rgn3ra(&mut self) -> _RGN3RAW {
1470 _RGN3RAW { w: self }
1471 }
1472 #[doc = "Bit 24 - Enable/disable write access watch in PREGION[0]"]
1473 #[inline]
1474 pub fn prgn0wa(&mut self) -> _PRGN0WAW {
1475 _PRGN0WAW { w: self }
1476 }
1477 #[doc = "Bit 25 - Enable/disable read access watch in PREGION[0]"]
1478 #[inline]
1479 pub fn prgn0ra(&mut self) -> _PRGN0RAW {
1480 _PRGN0RAW { w: self }
1481 }
1482 #[doc = "Bit 26 - Enable/disable write access watch in PREGION[1]"]
1483 #[inline]
1484 pub fn prgn1wa(&mut self) -> _PRGN1WAW {
1485 _PRGN1WAW { w: self }
1486 }
1487 #[doc = "Bit 27 - Enable/disable read access watch in PREGION[1]"]
1488 #[inline]
1489 pub fn prgn1ra(&mut self) -> _PRGN1RAW {
1490 _PRGN1RAW { w: self }
1491 }
1492}