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::PACRL {
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 `TP7`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum TP7R {
48 #[doc = "Accesses from an untrusted master are allowed."]
49 _0,
50 #[doc = "Accesses from an untrusted master are not allowed."]
51 _1,
52}
53impl TP7R {
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 TP7R::_0 => false,
69 TP7R::_1 => true,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> TP7R {
76 match value {
77 false => TP7R::_0,
78 true => TP7R::_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 == TP7R::_0
85 }
86 #[doc = "Checks if the value of the field is `_1`"]
87 #[inline]
88 pub fn is_1(&self) -> bool {
89 *self == TP7R::_1
90 }
91}
92#[doc = "Possible values of the field `WP7`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum WP7R {
95 #[doc = "This peripheral allows write accesses."]
96 _0,
97 #[doc = "This peripheral is write protected."]
98 _1,
99}
100impl WP7R {
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 WP7R::_0 => false,
116 WP7R::_1 => true,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> WP7R {
123 match value {
124 false => WP7R::_0,
125 true => WP7R::_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 == WP7R::_0
132 }
133 #[doc = "Checks if the value of the field is `_1`"]
134 #[inline]
135 pub fn is_1(&self) -> bool {
136 *self == WP7R::_1
137 }
138}
139#[doc = "Possible values of the field `SP7`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum SP7R {
142 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
143 _0,
144 #[doc = "This peripheral requires supervisor privilege level for accesses."]
145 _1,
146}
147impl SP7R {
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 SP7R::_0 => false,
163 SP7R::_1 => true,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> SP7R {
170 match value {
171 false => SP7R::_0,
172 true => SP7R::_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 == SP7R::_0
179 }
180 #[doc = "Checks if the value of the field is `_1`"]
181 #[inline]
182 pub fn is_1(&self) -> bool {
183 *self == SP7R::_1
184 }
185}
186#[doc = "Possible values of the field `TP6`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum TP6R {
189 #[doc = "Accesses from an untrusted master are allowed."]
190 _0,
191 #[doc = "Accesses from an untrusted master are not allowed."]
192 _1,
193}
194impl TP6R {
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 TP6R::_0 => false,
210 TP6R::_1 => true,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> TP6R {
217 match value {
218 false => TP6R::_0,
219 true => TP6R::_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 == TP6R::_0
226 }
227 #[doc = "Checks if the value of the field is `_1`"]
228 #[inline]
229 pub fn is_1(&self) -> bool {
230 *self == TP6R::_1
231 }
232}
233#[doc = "Possible values of the field `WP6`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum WP6R {
236 #[doc = "This peripheral allows write accesses."]
237 _0,
238 #[doc = "This peripheral is write protected."]
239 _1,
240}
241impl WP6R {
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 WP6R::_0 => false,
257 WP6R::_1 => true,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> WP6R {
264 match value {
265 false => WP6R::_0,
266 true => WP6R::_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 == WP6R::_0
273 }
274 #[doc = "Checks if the value of the field is `_1`"]
275 #[inline]
276 pub fn is_1(&self) -> bool {
277 *self == WP6R::_1
278 }
279}
280#[doc = "Possible values of the field `SP6`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum SP6R {
283 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
284 _0,
285 #[doc = "This peripheral requires supervisor privilege level for accesses."]
286 _1,
287}
288impl SP6R {
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 SP6R::_0 => false,
304 SP6R::_1 => true,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> SP6R {
311 match value {
312 false => SP6R::_0,
313 true => SP6R::_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 == SP6R::_0
320 }
321 #[doc = "Checks if the value of the field is `_1`"]
322 #[inline]
323 pub fn is_1(&self) -> bool {
324 *self == SP6R::_1
325 }
326}
327#[doc = "Possible values of the field `TP5`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum TP5R {
330 #[doc = "Accesses from an untrusted master are allowed."]
331 _0,
332 #[doc = "Accesses from an untrusted master are not allowed."]
333 _1,
334}
335impl TP5R {
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 TP5R::_0 => false,
351 TP5R::_1 => true,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> TP5R {
358 match value {
359 false => TP5R::_0,
360 true => TP5R::_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 == TP5R::_0
367 }
368 #[doc = "Checks if the value of the field is `_1`"]
369 #[inline]
370 pub fn is_1(&self) -> bool {
371 *self == TP5R::_1
372 }
373}
374#[doc = "Possible values of the field `WP5`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum WP5R {
377 #[doc = "This peripheral allows write accesses."]
378 _0,
379 #[doc = "This peripheral is write protected."]
380 _1,
381}
382impl WP5R {
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 WP5R::_0 => false,
398 WP5R::_1 => true,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> WP5R {
405 match value {
406 false => WP5R::_0,
407 true => WP5R::_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 == WP5R::_0
414 }
415 #[doc = "Checks if the value of the field is `_1`"]
416 #[inline]
417 pub fn is_1(&self) -> bool {
418 *self == WP5R::_1
419 }
420}
421#[doc = "Possible values of the field `SP5`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum SP5R {
424 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
425 _0,
426 #[doc = "This peripheral requires supervisor privilege level for accesses."]
427 _1,
428}
429impl SP5R {
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 SP5R::_0 => false,
445 SP5R::_1 => true,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> SP5R {
452 match value {
453 false => SP5R::_0,
454 true => SP5R::_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 == SP5R::_0
461 }
462 #[doc = "Checks if the value of the field is `_1`"]
463 #[inline]
464 pub fn is_1(&self) -> bool {
465 *self == SP5R::_1
466 }
467}
468#[doc = "Possible values of the field `TP4`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum TP4R {
471 #[doc = "Accesses from an untrusted master are allowed."]
472 _0,
473 #[doc = "Accesses from an untrusted master are not allowed."]
474 _1,
475}
476impl TP4R {
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 TP4R::_0 => false,
492 TP4R::_1 => true,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> TP4R {
499 match value {
500 false => TP4R::_0,
501 true => TP4R::_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 == TP4R::_0
508 }
509 #[doc = "Checks if the value of the field is `_1`"]
510 #[inline]
511 pub fn is_1(&self) -> bool {
512 *self == TP4R::_1
513 }
514}
515#[doc = "Possible values of the field `WP4`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum WP4R {
518 #[doc = "This peripheral allows write accesses."]
519 _0,
520 #[doc = "This peripheral is write protected."]
521 _1,
522}
523impl WP4R {
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 WP4R::_0 => false,
539 WP4R::_1 => true,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> WP4R {
546 match value {
547 false => WP4R::_0,
548 true => WP4R::_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 == WP4R::_0
555 }
556 #[doc = "Checks if the value of the field is `_1`"]
557 #[inline]
558 pub fn is_1(&self) -> bool {
559 *self == WP4R::_1
560 }
561}
562#[doc = "Possible values of the field `SP4`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum SP4R {
565 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
566 _0,
567 #[doc = "This peripheral requires supervisor privilege level for accesses."]
568 _1,
569}
570impl SP4R {
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 SP4R::_0 => false,
586 SP4R::_1 => true,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> SP4R {
593 match value {
594 false => SP4R::_0,
595 true => SP4R::_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 == SP4R::_0
602 }
603 #[doc = "Checks if the value of the field is `_1`"]
604 #[inline]
605 pub fn is_1(&self) -> bool {
606 *self == SP4R::_1
607 }
608}
609#[doc = "Possible values of the field `TP3`"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum TP3R {
612 #[doc = "Accesses from an untrusted master are allowed."]
613 _0,
614 #[doc = "Accesses from an untrusted master are not allowed."]
615 _1,
616}
617impl TP3R {
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 TP3R::_0 => false,
633 TP3R::_1 => true,
634 }
635 }
636 #[allow(missing_docs)]
637 #[doc(hidden)]
638 #[inline]
639 pub fn _from(value: bool) -> TP3R {
640 match value {
641 false => TP3R::_0,
642 true => TP3R::_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 == TP3R::_0
649 }
650 #[doc = "Checks if the value of the field is `_1`"]
651 #[inline]
652 pub fn is_1(&self) -> bool {
653 *self == TP3R::_1
654 }
655}
656#[doc = "Possible values of the field `WP3`"]
657#[derive(Clone, Copy, Debug, PartialEq)]
658pub enum WP3R {
659 #[doc = "This peripheral allows write accesses."]
660 _0,
661 #[doc = "This peripheral is write protected."]
662 _1,
663}
664impl WP3R {
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 WP3R::_0 => false,
680 WP3R::_1 => true,
681 }
682 }
683 #[allow(missing_docs)]
684 #[doc(hidden)]
685 #[inline]
686 pub fn _from(value: bool) -> WP3R {
687 match value {
688 false => WP3R::_0,
689 true => WP3R::_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 == WP3R::_0
696 }
697 #[doc = "Checks if the value of the field is `_1`"]
698 #[inline]
699 pub fn is_1(&self) -> bool {
700 *self == WP3R::_1
701 }
702}
703#[doc = "Possible values of the field `SP3`"]
704#[derive(Clone, Copy, Debug, PartialEq)]
705pub enum SP3R {
706 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
707 _0,
708 #[doc = "This peripheral requires supervisor privilege level for accesses."]
709 _1,
710}
711impl SP3R {
712 #[doc = r" Returns `true` if the bit is clear (0)"]
713 #[inline]
714 pub fn bit_is_clear(&self) -> bool {
715 !self.bit()
716 }
717 #[doc = r" Returns `true` if the bit is set (1)"]
718 #[inline]
719 pub fn bit_is_set(&self) -> bool {
720 self.bit()
721 }
722 #[doc = r" Value of the field as raw bits"]
723 #[inline]
724 pub fn bit(&self) -> bool {
725 match *self {
726 SP3R::_0 => false,
727 SP3R::_1 => true,
728 }
729 }
730 #[allow(missing_docs)]
731 #[doc(hidden)]
732 #[inline]
733 pub fn _from(value: bool) -> SP3R {
734 match value {
735 false => SP3R::_0,
736 true => SP3R::_1,
737 }
738 }
739 #[doc = "Checks if the value of the field is `_0`"]
740 #[inline]
741 pub fn is_0(&self) -> bool {
742 *self == SP3R::_0
743 }
744 #[doc = "Checks if the value of the field is `_1`"]
745 #[inline]
746 pub fn is_1(&self) -> bool {
747 *self == SP3R::_1
748 }
749}
750#[doc = "Possible values of the field `TP2`"]
751#[derive(Clone, Copy, Debug, PartialEq)]
752pub enum TP2R {
753 #[doc = "Accesses from an untrusted master are allowed."]
754 _0,
755 #[doc = "Accesses from an untrusted master are not allowed."]
756 _1,
757}
758impl TP2R {
759 #[doc = r" Returns `true` if the bit is clear (0)"]
760 #[inline]
761 pub fn bit_is_clear(&self) -> bool {
762 !self.bit()
763 }
764 #[doc = r" Returns `true` if the bit is set (1)"]
765 #[inline]
766 pub fn bit_is_set(&self) -> bool {
767 self.bit()
768 }
769 #[doc = r" Value of the field as raw bits"]
770 #[inline]
771 pub fn bit(&self) -> bool {
772 match *self {
773 TP2R::_0 => false,
774 TP2R::_1 => true,
775 }
776 }
777 #[allow(missing_docs)]
778 #[doc(hidden)]
779 #[inline]
780 pub fn _from(value: bool) -> TP2R {
781 match value {
782 false => TP2R::_0,
783 true => TP2R::_1,
784 }
785 }
786 #[doc = "Checks if the value of the field is `_0`"]
787 #[inline]
788 pub fn is_0(&self) -> bool {
789 *self == TP2R::_0
790 }
791 #[doc = "Checks if the value of the field is `_1`"]
792 #[inline]
793 pub fn is_1(&self) -> bool {
794 *self == TP2R::_1
795 }
796}
797#[doc = "Possible values of the field `WP2`"]
798#[derive(Clone, Copy, Debug, PartialEq)]
799pub enum WP2R {
800 #[doc = "This peripheral allows write accesses."]
801 _0,
802 #[doc = "This peripheral is write protected."]
803 _1,
804}
805impl WP2R {
806 #[doc = r" Returns `true` if the bit is clear (0)"]
807 #[inline]
808 pub fn bit_is_clear(&self) -> bool {
809 !self.bit()
810 }
811 #[doc = r" Returns `true` if the bit is set (1)"]
812 #[inline]
813 pub fn bit_is_set(&self) -> bool {
814 self.bit()
815 }
816 #[doc = r" Value of the field as raw bits"]
817 #[inline]
818 pub fn bit(&self) -> bool {
819 match *self {
820 WP2R::_0 => false,
821 WP2R::_1 => true,
822 }
823 }
824 #[allow(missing_docs)]
825 #[doc(hidden)]
826 #[inline]
827 pub fn _from(value: bool) -> WP2R {
828 match value {
829 false => WP2R::_0,
830 true => WP2R::_1,
831 }
832 }
833 #[doc = "Checks if the value of the field is `_0`"]
834 #[inline]
835 pub fn is_0(&self) -> bool {
836 *self == WP2R::_0
837 }
838 #[doc = "Checks if the value of the field is `_1`"]
839 #[inline]
840 pub fn is_1(&self) -> bool {
841 *self == WP2R::_1
842 }
843}
844#[doc = "Possible values of the field `SP2`"]
845#[derive(Clone, Copy, Debug, PartialEq)]
846pub enum SP2R {
847 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
848 _0,
849 #[doc = "This peripheral requires supervisor privilege level for accesses."]
850 _1,
851}
852impl SP2R {
853 #[doc = r" Returns `true` if the bit is clear (0)"]
854 #[inline]
855 pub fn bit_is_clear(&self) -> bool {
856 !self.bit()
857 }
858 #[doc = r" Returns `true` if the bit is set (1)"]
859 #[inline]
860 pub fn bit_is_set(&self) -> bool {
861 self.bit()
862 }
863 #[doc = r" Value of the field as raw bits"]
864 #[inline]
865 pub fn bit(&self) -> bool {
866 match *self {
867 SP2R::_0 => false,
868 SP2R::_1 => true,
869 }
870 }
871 #[allow(missing_docs)]
872 #[doc(hidden)]
873 #[inline]
874 pub fn _from(value: bool) -> SP2R {
875 match value {
876 false => SP2R::_0,
877 true => SP2R::_1,
878 }
879 }
880 #[doc = "Checks if the value of the field is `_0`"]
881 #[inline]
882 pub fn is_0(&self) -> bool {
883 *self == SP2R::_0
884 }
885 #[doc = "Checks if the value of the field is `_1`"]
886 #[inline]
887 pub fn is_1(&self) -> bool {
888 *self == SP2R::_1
889 }
890}
891#[doc = "Possible values of the field `TP1`"]
892#[derive(Clone, Copy, Debug, PartialEq)]
893pub enum TP1R {
894 #[doc = "Accesses from an untrusted master are allowed."]
895 _0,
896 #[doc = "Accesses from an untrusted master are not allowed."]
897 _1,
898}
899impl TP1R {
900 #[doc = r" Returns `true` if the bit is clear (0)"]
901 #[inline]
902 pub fn bit_is_clear(&self) -> bool {
903 !self.bit()
904 }
905 #[doc = r" Returns `true` if the bit is set (1)"]
906 #[inline]
907 pub fn bit_is_set(&self) -> bool {
908 self.bit()
909 }
910 #[doc = r" Value of the field as raw bits"]
911 #[inline]
912 pub fn bit(&self) -> bool {
913 match *self {
914 TP1R::_0 => false,
915 TP1R::_1 => true,
916 }
917 }
918 #[allow(missing_docs)]
919 #[doc(hidden)]
920 #[inline]
921 pub fn _from(value: bool) -> TP1R {
922 match value {
923 false => TP1R::_0,
924 true => TP1R::_1,
925 }
926 }
927 #[doc = "Checks if the value of the field is `_0`"]
928 #[inline]
929 pub fn is_0(&self) -> bool {
930 *self == TP1R::_0
931 }
932 #[doc = "Checks if the value of the field is `_1`"]
933 #[inline]
934 pub fn is_1(&self) -> bool {
935 *self == TP1R::_1
936 }
937}
938#[doc = "Possible values of the field `WP1`"]
939#[derive(Clone, Copy, Debug, PartialEq)]
940pub enum WP1R {
941 #[doc = "This peripheral allows write accesses."]
942 _0,
943 #[doc = "This peripheral is write protected."]
944 _1,
945}
946impl WP1R {
947 #[doc = r" Returns `true` if the bit is clear (0)"]
948 #[inline]
949 pub fn bit_is_clear(&self) -> bool {
950 !self.bit()
951 }
952 #[doc = r" Returns `true` if the bit is set (1)"]
953 #[inline]
954 pub fn bit_is_set(&self) -> bool {
955 self.bit()
956 }
957 #[doc = r" Value of the field as raw bits"]
958 #[inline]
959 pub fn bit(&self) -> bool {
960 match *self {
961 WP1R::_0 => false,
962 WP1R::_1 => true,
963 }
964 }
965 #[allow(missing_docs)]
966 #[doc(hidden)]
967 #[inline]
968 pub fn _from(value: bool) -> WP1R {
969 match value {
970 false => WP1R::_0,
971 true => WP1R::_1,
972 }
973 }
974 #[doc = "Checks if the value of the field is `_0`"]
975 #[inline]
976 pub fn is_0(&self) -> bool {
977 *self == WP1R::_0
978 }
979 #[doc = "Checks if the value of the field is `_1`"]
980 #[inline]
981 pub fn is_1(&self) -> bool {
982 *self == WP1R::_1
983 }
984}
985#[doc = "Possible values of the field `SP1`"]
986#[derive(Clone, Copy, Debug, PartialEq)]
987pub enum SP1R {
988 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
989 _0,
990 #[doc = "This peripheral requires supervisor privilege level for accesses."]
991 _1,
992}
993impl SP1R {
994 #[doc = r" Returns `true` if the bit is clear (0)"]
995 #[inline]
996 pub fn bit_is_clear(&self) -> bool {
997 !self.bit()
998 }
999 #[doc = r" Returns `true` if the bit is set (1)"]
1000 #[inline]
1001 pub fn bit_is_set(&self) -> bool {
1002 self.bit()
1003 }
1004 #[doc = r" Value of the field as raw bits"]
1005 #[inline]
1006 pub fn bit(&self) -> bool {
1007 match *self {
1008 SP1R::_0 => false,
1009 SP1R::_1 => true,
1010 }
1011 }
1012 #[allow(missing_docs)]
1013 #[doc(hidden)]
1014 #[inline]
1015 pub fn _from(value: bool) -> SP1R {
1016 match value {
1017 false => SP1R::_0,
1018 true => SP1R::_1,
1019 }
1020 }
1021 #[doc = "Checks if the value of the field is `_0`"]
1022 #[inline]
1023 pub fn is_0(&self) -> bool {
1024 *self == SP1R::_0
1025 }
1026 #[doc = "Checks if the value of the field is `_1`"]
1027 #[inline]
1028 pub fn is_1(&self) -> bool {
1029 *self == SP1R::_1
1030 }
1031}
1032#[doc = "Possible values of the field `TP0`"]
1033#[derive(Clone, Copy, Debug, PartialEq)]
1034pub enum TP0R {
1035 #[doc = "Accesses from an untrusted master are allowed."]
1036 _0,
1037 #[doc = "Accesses from an untrusted master are not allowed."]
1038 _1,
1039}
1040impl TP0R {
1041 #[doc = r" Returns `true` if the bit is clear (0)"]
1042 #[inline]
1043 pub fn bit_is_clear(&self) -> bool {
1044 !self.bit()
1045 }
1046 #[doc = r" Returns `true` if the bit is set (1)"]
1047 #[inline]
1048 pub fn bit_is_set(&self) -> bool {
1049 self.bit()
1050 }
1051 #[doc = r" Value of the field as raw bits"]
1052 #[inline]
1053 pub fn bit(&self) -> bool {
1054 match *self {
1055 TP0R::_0 => false,
1056 TP0R::_1 => true,
1057 }
1058 }
1059 #[allow(missing_docs)]
1060 #[doc(hidden)]
1061 #[inline]
1062 pub fn _from(value: bool) -> TP0R {
1063 match value {
1064 false => TP0R::_0,
1065 true => TP0R::_1,
1066 }
1067 }
1068 #[doc = "Checks if the value of the field is `_0`"]
1069 #[inline]
1070 pub fn is_0(&self) -> bool {
1071 *self == TP0R::_0
1072 }
1073 #[doc = "Checks if the value of the field is `_1`"]
1074 #[inline]
1075 pub fn is_1(&self) -> bool {
1076 *self == TP0R::_1
1077 }
1078}
1079#[doc = "Possible values of the field `WP0`"]
1080#[derive(Clone, Copy, Debug, PartialEq)]
1081pub enum WP0R {
1082 #[doc = "This peripheral allows write accesses."]
1083 _0,
1084 #[doc = "This peripheral is write protected."]
1085 _1,
1086}
1087impl WP0R {
1088 #[doc = r" Returns `true` if the bit is clear (0)"]
1089 #[inline]
1090 pub fn bit_is_clear(&self) -> bool {
1091 !self.bit()
1092 }
1093 #[doc = r" Returns `true` if the bit is set (1)"]
1094 #[inline]
1095 pub fn bit_is_set(&self) -> bool {
1096 self.bit()
1097 }
1098 #[doc = r" Value of the field as raw bits"]
1099 #[inline]
1100 pub fn bit(&self) -> bool {
1101 match *self {
1102 WP0R::_0 => false,
1103 WP0R::_1 => true,
1104 }
1105 }
1106 #[allow(missing_docs)]
1107 #[doc(hidden)]
1108 #[inline]
1109 pub fn _from(value: bool) -> WP0R {
1110 match value {
1111 false => WP0R::_0,
1112 true => WP0R::_1,
1113 }
1114 }
1115 #[doc = "Checks if the value of the field is `_0`"]
1116 #[inline]
1117 pub fn is_0(&self) -> bool {
1118 *self == WP0R::_0
1119 }
1120 #[doc = "Checks if the value of the field is `_1`"]
1121 #[inline]
1122 pub fn is_1(&self) -> bool {
1123 *self == WP0R::_1
1124 }
1125}
1126#[doc = "Possible values of the field `SP0`"]
1127#[derive(Clone, Copy, Debug, PartialEq)]
1128pub enum SP0R {
1129 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1130 _0,
1131 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1132 _1,
1133}
1134impl SP0R {
1135 #[doc = r" Returns `true` if the bit is clear (0)"]
1136 #[inline]
1137 pub fn bit_is_clear(&self) -> bool {
1138 !self.bit()
1139 }
1140 #[doc = r" Returns `true` if the bit is set (1)"]
1141 #[inline]
1142 pub fn bit_is_set(&self) -> bool {
1143 self.bit()
1144 }
1145 #[doc = r" Value of the field as raw bits"]
1146 #[inline]
1147 pub fn bit(&self) -> bool {
1148 match *self {
1149 SP0R::_0 => false,
1150 SP0R::_1 => true,
1151 }
1152 }
1153 #[allow(missing_docs)]
1154 #[doc(hidden)]
1155 #[inline]
1156 pub fn _from(value: bool) -> SP0R {
1157 match value {
1158 false => SP0R::_0,
1159 true => SP0R::_1,
1160 }
1161 }
1162 #[doc = "Checks if the value of the field is `_0`"]
1163 #[inline]
1164 pub fn is_0(&self) -> bool {
1165 *self == SP0R::_0
1166 }
1167 #[doc = "Checks if the value of the field is `_1`"]
1168 #[inline]
1169 pub fn is_1(&self) -> bool {
1170 *self == SP0R::_1
1171 }
1172}
1173#[doc = "Values that can be written to the field `TP7`"]
1174pub enum TP7W {
1175 #[doc = "Accesses from an untrusted master are allowed."]
1176 _0,
1177 #[doc = "Accesses from an untrusted master are not allowed."]
1178 _1,
1179}
1180impl TP7W {
1181 #[allow(missing_docs)]
1182 #[doc(hidden)]
1183 #[inline]
1184 pub fn _bits(&self) -> bool {
1185 match *self {
1186 TP7W::_0 => false,
1187 TP7W::_1 => true,
1188 }
1189 }
1190}
1191#[doc = r" Proxy"]
1192pub struct _TP7W<'a> {
1193 w: &'a mut W,
1194}
1195impl<'a> _TP7W<'a> {
1196 #[doc = r" Writes `variant` to the field"]
1197 #[inline]
1198 pub fn variant(self, variant: TP7W) -> &'a mut W {
1199 {
1200 self.bit(variant._bits())
1201 }
1202 }
1203 #[doc = "Accesses from an untrusted master are allowed."]
1204 #[inline]
1205 pub fn _0(self) -> &'a mut W {
1206 self.variant(TP7W::_0)
1207 }
1208 #[doc = "Accesses from an untrusted master are not allowed."]
1209 #[inline]
1210 pub fn _1(self) -> &'a mut W {
1211 self.variant(TP7W::_1)
1212 }
1213 #[doc = r" Sets the field bit"]
1214 pub fn set_bit(self) -> &'a mut W {
1215 self.bit(true)
1216 }
1217 #[doc = r" Clears the field bit"]
1218 pub fn clear_bit(self) -> &'a mut W {
1219 self.bit(false)
1220 }
1221 #[doc = r" Writes raw bits to the field"]
1222 #[inline]
1223 pub fn bit(self, value: bool) -> &'a mut W {
1224 const MASK: bool = true;
1225 const OFFSET: u8 = 0;
1226 self.w.bits &= !((MASK as u32) << OFFSET);
1227 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1228 self.w
1229 }
1230}
1231#[doc = "Values that can be written to the field `WP7`"]
1232pub enum WP7W {
1233 #[doc = "This peripheral allows write accesses."]
1234 _0,
1235 #[doc = "This peripheral is write protected."]
1236 _1,
1237}
1238impl WP7W {
1239 #[allow(missing_docs)]
1240 #[doc(hidden)]
1241 #[inline]
1242 pub fn _bits(&self) -> bool {
1243 match *self {
1244 WP7W::_0 => false,
1245 WP7W::_1 => true,
1246 }
1247 }
1248}
1249#[doc = r" Proxy"]
1250pub struct _WP7W<'a> {
1251 w: &'a mut W,
1252}
1253impl<'a> _WP7W<'a> {
1254 #[doc = r" Writes `variant` to the field"]
1255 #[inline]
1256 pub fn variant(self, variant: WP7W) -> &'a mut W {
1257 {
1258 self.bit(variant._bits())
1259 }
1260 }
1261 #[doc = "This peripheral allows write accesses."]
1262 #[inline]
1263 pub fn _0(self) -> &'a mut W {
1264 self.variant(WP7W::_0)
1265 }
1266 #[doc = "This peripheral is write protected."]
1267 #[inline]
1268 pub fn _1(self) -> &'a mut W {
1269 self.variant(WP7W::_1)
1270 }
1271 #[doc = r" Sets the field bit"]
1272 pub fn set_bit(self) -> &'a mut W {
1273 self.bit(true)
1274 }
1275 #[doc = r" Clears the field bit"]
1276 pub fn clear_bit(self) -> &'a mut W {
1277 self.bit(false)
1278 }
1279 #[doc = r" Writes raw bits to the field"]
1280 #[inline]
1281 pub fn bit(self, value: bool) -> &'a mut W {
1282 const MASK: bool = true;
1283 const OFFSET: u8 = 1;
1284 self.w.bits &= !((MASK as u32) << OFFSET);
1285 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1286 self.w
1287 }
1288}
1289#[doc = "Values that can be written to the field `SP7`"]
1290pub enum SP7W {
1291 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1292 _0,
1293 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1294 _1,
1295}
1296impl SP7W {
1297 #[allow(missing_docs)]
1298 #[doc(hidden)]
1299 #[inline]
1300 pub fn _bits(&self) -> bool {
1301 match *self {
1302 SP7W::_0 => false,
1303 SP7W::_1 => true,
1304 }
1305 }
1306}
1307#[doc = r" Proxy"]
1308pub struct _SP7W<'a> {
1309 w: &'a mut W,
1310}
1311impl<'a> _SP7W<'a> {
1312 #[doc = r" Writes `variant` to the field"]
1313 #[inline]
1314 pub fn variant(self, variant: SP7W) -> &'a mut W {
1315 {
1316 self.bit(variant._bits())
1317 }
1318 }
1319 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1320 #[inline]
1321 pub fn _0(self) -> &'a mut W {
1322 self.variant(SP7W::_0)
1323 }
1324 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1325 #[inline]
1326 pub fn _1(self) -> &'a mut W {
1327 self.variant(SP7W::_1)
1328 }
1329 #[doc = r" Sets the field bit"]
1330 pub fn set_bit(self) -> &'a mut W {
1331 self.bit(true)
1332 }
1333 #[doc = r" Clears the field bit"]
1334 pub fn clear_bit(self) -> &'a mut W {
1335 self.bit(false)
1336 }
1337 #[doc = r" Writes raw bits to the field"]
1338 #[inline]
1339 pub fn bit(self, value: bool) -> &'a mut W {
1340 const MASK: bool = true;
1341 const OFFSET: u8 = 2;
1342 self.w.bits &= !((MASK as u32) << OFFSET);
1343 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1344 self.w
1345 }
1346}
1347#[doc = "Values that can be written to the field `TP6`"]
1348pub enum TP6W {
1349 #[doc = "Accesses from an untrusted master are allowed."]
1350 _0,
1351 #[doc = "Accesses from an untrusted master are not allowed."]
1352 _1,
1353}
1354impl TP6W {
1355 #[allow(missing_docs)]
1356 #[doc(hidden)]
1357 #[inline]
1358 pub fn _bits(&self) -> bool {
1359 match *self {
1360 TP6W::_0 => false,
1361 TP6W::_1 => true,
1362 }
1363 }
1364}
1365#[doc = r" Proxy"]
1366pub struct _TP6W<'a> {
1367 w: &'a mut W,
1368}
1369impl<'a> _TP6W<'a> {
1370 #[doc = r" Writes `variant` to the field"]
1371 #[inline]
1372 pub fn variant(self, variant: TP6W) -> &'a mut W {
1373 {
1374 self.bit(variant._bits())
1375 }
1376 }
1377 #[doc = "Accesses from an untrusted master are allowed."]
1378 #[inline]
1379 pub fn _0(self) -> &'a mut W {
1380 self.variant(TP6W::_0)
1381 }
1382 #[doc = "Accesses from an untrusted master are not allowed."]
1383 #[inline]
1384 pub fn _1(self) -> &'a mut W {
1385 self.variant(TP6W::_1)
1386 }
1387 #[doc = r" Sets the field bit"]
1388 pub fn set_bit(self) -> &'a mut W {
1389 self.bit(true)
1390 }
1391 #[doc = r" Clears the field bit"]
1392 pub fn clear_bit(self) -> &'a mut W {
1393 self.bit(false)
1394 }
1395 #[doc = r" Writes raw bits to the field"]
1396 #[inline]
1397 pub fn bit(self, value: bool) -> &'a mut W {
1398 const MASK: bool = true;
1399 const OFFSET: u8 = 4;
1400 self.w.bits &= !((MASK as u32) << OFFSET);
1401 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1402 self.w
1403 }
1404}
1405#[doc = "Values that can be written to the field `WP6`"]
1406pub enum WP6W {
1407 #[doc = "This peripheral allows write accesses."]
1408 _0,
1409 #[doc = "This peripheral is write protected."]
1410 _1,
1411}
1412impl WP6W {
1413 #[allow(missing_docs)]
1414 #[doc(hidden)]
1415 #[inline]
1416 pub fn _bits(&self) -> bool {
1417 match *self {
1418 WP6W::_0 => false,
1419 WP6W::_1 => true,
1420 }
1421 }
1422}
1423#[doc = r" Proxy"]
1424pub struct _WP6W<'a> {
1425 w: &'a mut W,
1426}
1427impl<'a> _WP6W<'a> {
1428 #[doc = r" Writes `variant` to the field"]
1429 #[inline]
1430 pub fn variant(self, variant: WP6W) -> &'a mut W {
1431 {
1432 self.bit(variant._bits())
1433 }
1434 }
1435 #[doc = "This peripheral allows write accesses."]
1436 #[inline]
1437 pub fn _0(self) -> &'a mut W {
1438 self.variant(WP6W::_0)
1439 }
1440 #[doc = "This peripheral is write protected."]
1441 #[inline]
1442 pub fn _1(self) -> &'a mut W {
1443 self.variant(WP6W::_1)
1444 }
1445 #[doc = r" Sets the field bit"]
1446 pub fn set_bit(self) -> &'a mut W {
1447 self.bit(true)
1448 }
1449 #[doc = r" Clears the field bit"]
1450 pub fn clear_bit(self) -> &'a mut W {
1451 self.bit(false)
1452 }
1453 #[doc = r" Writes raw bits to the field"]
1454 #[inline]
1455 pub fn bit(self, value: bool) -> &'a mut W {
1456 const MASK: bool = true;
1457 const OFFSET: u8 = 5;
1458 self.w.bits &= !((MASK as u32) << OFFSET);
1459 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1460 self.w
1461 }
1462}
1463#[doc = "Values that can be written to the field `SP6`"]
1464pub enum SP6W {
1465 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1466 _0,
1467 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1468 _1,
1469}
1470impl SP6W {
1471 #[allow(missing_docs)]
1472 #[doc(hidden)]
1473 #[inline]
1474 pub fn _bits(&self) -> bool {
1475 match *self {
1476 SP6W::_0 => false,
1477 SP6W::_1 => true,
1478 }
1479 }
1480}
1481#[doc = r" Proxy"]
1482pub struct _SP6W<'a> {
1483 w: &'a mut W,
1484}
1485impl<'a> _SP6W<'a> {
1486 #[doc = r" Writes `variant` to the field"]
1487 #[inline]
1488 pub fn variant(self, variant: SP6W) -> &'a mut W {
1489 {
1490 self.bit(variant._bits())
1491 }
1492 }
1493 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1494 #[inline]
1495 pub fn _0(self) -> &'a mut W {
1496 self.variant(SP6W::_0)
1497 }
1498 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1499 #[inline]
1500 pub fn _1(self) -> &'a mut W {
1501 self.variant(SP6W::_1)
1502 }
1503 #[doc = r" Sets the field bit"]
1504 pub fn set_bit(self) -> &'a mut W {
1505 self.bit(true)
1506 }
1507 #[doc = r" Clears the field bit"]
1508 pub fn clear_bit(self) -> &'a mut W {
1509 self.bit(false)
1510 }
1511 #[doc = r" Writes raw bits to the field"]
1512 #[inline]
1513 pub fn bit(self, value: bool) -> &'a mut W {
1514 const MASK: bool = true;
1515 const OFFSET: u8 = 6;
1516 self.w.bits &= !((MASK as u32) << OFFSET);
1517 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1518 self.w
1519 }
1520}
1521#[doc = "Values that can be written to the field `TP5`"]
1522pub enum TP5W {
1523 #[doc = "Accesses from an untrusted master are allowed."]
1524 _0,
1525 #[doc = "Accesses from an untrusted master are not allowed."]
1526 _1,
1527}
1528impl TP5W {
1529 #[allow(missing_docs)]
1530 #[doc(hidden)]
1531 #[inline]
1532 pub fn _bits(&self) -> bool {
1533 match *self {
1534 TP5W::_0 => false,
1535 TP5W::_1 => true,
1536 }
1537 }
1538}
1539#[doc = r" Proxy"]
1540pub struct _TP5W<'a> {
1541 w: &'a mut W,
1542}
1543impl<'a> _TP5W<'a> {
1544 #[doc = r" Writes `variant` to the field"]
1545 #[inline]
1546 pub fn variant(self, variant: TP5W) -> &'a mut W {
1547 {
1548 self.bit(variant._bits())
1549 }
1550 }
1551 #[doc = "Accesses from an untrusted master are allowed."]
1552 #[inline]
1553 pub fn _0(self) -> &'a mut W {
1554 self.variant(TP5W::_0)
1555 }
1556 #[doc = "Accesses from an untrusted master are not allowed."]
1557 #[inline]
1558 pub fn _1(self) -> &'a mut W {
1559 self.variant(TP5W::_1)
1560 }
1561 #[doc = r" Sets the field bit"]
1562 pub fn set_bit(self) -> &'a mut W {
1563 self.bit(true)
1564 }
1565 #[doc = r" Clears the field bit"]
1566 pub fn clear_bit(self) -> &'a mut W {
1567 self.bit(false)
1568 }
1569 #[doc = r" Writes raw bits to the field"]
1570 #[inline]
1571 pub fn bit(self, value: bool) -> &'a mut W {
1572 const MASK: bool = true;
1573 const OFFSET: u8 = 8;
1574 self.w.bits &= !((MASK as u32) << OFFSET);
1575 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1576 self.w
1577 }
1578}
1579#[doc = "Values that can be written to the field `WP5`"]
1580pub enum WP5W {
1581 #[doc = "This peripheral allows write accesses."]
1582 _0,
1583 #[doc = "This peripheral is write protected."]
1584 _1,
1585}
1586impl WP5W {
1587 #[allow(missing_docs)]
1588 #[doc(hidden)]
1589 #[inline]
1590 pub fn _bits(&self) -> bool {
1591 match *self {
1592 WP5W::_0 => false,
1593 WP5W::_1 => true,
1594 }
1595 }
1596}
1597#[doc = r" Proxy"]
1598pub struct _WP5W<'a> {
1599 w: &'a mut W,
1600}
1601impl<'a> _WP5W<'a> {
1602 #[doc = r" Writes `variant` to the field"]
1603 #[inline]
1604 pub fn variant(self, variant: WP5W) -> &'a mut W {
1605 {
1606 self.bit(variant._bits())
1607 }
1608 }
1609 #[doc = "This peripheral allows write accesses."]
1610 #[inline]
1611 pub fn _0(self) -> &'a mut W {
1612 self.variant(WP5W::_0)
1613 }
1614 #[doc = "This peripheral is write protected."]
1615 #[inline]
1616 pub fn _1(self) -> &'a mut W {
1617 self.variant(WP5W::_1)
1618 }
1619 #[doc = r" Sets the field bit"]
1620 pub fn set_bit(self) -> &'a mut W {
1621 self.bit(true)
1622 }
1623 #[doc = r" Clears the field bit"]
1624 pub fn clear_bit(self) -> &'a mut W {
1625 self.bit(false)
1626 }
1627 #[doc = r" Writes raw bits to the field"]
1628 #[inline]
1629 pub fn bit(self, value: bool) -> &'a mut W {
1630 const MASK: bool = true;
1631 const OFFSET: u8 = 9;
1632 self.w.bits &= !((MASK as u32) << OFFSET);
1633 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1634 self.w
1635 }
1636}
1637#[doc = "Values that can be written to the field `SP5`"]
1638pub enum SP5W {
1639 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1640 _0,
1641 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1642 _1,
1643}
1644impl SP5W {
1645 #[allow(missing_docs)]
1646 #[doc(hidden)]
1647 #[inline]
1648 pub fn _bits(&self) -> bool {
1649 match *self {
1650 SP5W::_0 => false,
1651 SP5W::_1 => true,
1652 }
1653 }
1654}
1655#[doc = r" Proxy"]
1656pub struct _SP5W<'a> {
1657 w: &'a mut W,
1658}
1659impl<'a> _SP5W<'a> {
1660 #[doc = r" Writes `variant` to the field"]
1661 #[inline]
1662 pub fn variant(self, variant: SP5W) -> &'a mut W {
1663 {
1664 self.bit(variant._bits())
1665 }
1666 }
1667 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1668 #[inline]
1669 pub fn _0(self) -> &'a mut W {
1670 self.variant(SP5W::_0)
1671 }
1672 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1673 #[inline]
1674 pub fn _1(self) -> &'a mut W {
1675 self.variant(SP5W::_1)
1676 }
1677 #[doc = r" Sets the field bit"]
1678 pub fn set_bit(self) -> &'a mut W {
1679 self.bit(true)
1680 }
1681 #[doc = r" Clears the field bit"]
1682 pub fn clear_bit(self) -> &'a mut W {
1683 self.bit(false)
1684 }
1685 #[doc = r" Writes raw bits to the field"]
1686 #[inline]
1687 pub fn bit(self, value: bool) -> &'a mut W {
1688 const MASK: bool = true;
1689 const OFFSET: u8 = 10;
1690 self.w.bits &= !((MASK as u32) << OFFSET);
1691 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1692 self.w
1693 }
1694}
1695#[doc = "Values that can be written to the field `TP4`"]
1696pub enum TP4W {
1697 #[doc = "Accesses from an untrusted master are allowed."]
1698 _0,
1699 #[doc = "Accesses from an untrusted master are not allowed."]
1700 _1,
1701}
1702impl TP4W {
1703 #[allow(missing_docs)]
1704 #[doc(hidden)]
1705 #[inline]
1706 pub fn _bits(&self) -> bool {
1707 match *self {
1708 TP4W::_0 => false,
1709 TP4W::_1 => true,
1710 }
1711 }
1712}
1713#[doc = r" Proxy"]
1714pub struct _TP4W<'a> {
1715 w: &'a mut W,
1716}
1717impl<'a> _TP4W<'a> {
1718 #[doc = r" Writes `variant` to the field"]
1719 #[inline]
1720 pub fn variant(self, variant: TP4W) -> &'a mut W {
1721 {
1722 self.bit(variant._bits())
1723 }
1724 }
1725 #[doc = "Accesses from an untrusted master are allowed."]
1726 #[inline]
1727 pub fn _0(self) -> &'a mut W {
1728 self.variant(TP4W::_0)
1729 }
1730 #[doc = "Accesses from an untrusted master are not allowed."]
1731 #[inline]
1732 pub fn _1(self) -> &'a mut W {
1733 self.variant(TP4W::_1)
1734 }
1735 #[doc = r" Sets the field bit"]
1736 pub fn set_bit(self) -> &'a mut W {
1737 self.bit(true)
1738 }
1739 #[doc = r" Clears the field bit"]
1740 pub fn clear_bit(self) -> &'a mut W {
1741 self.bit(false)
1742 }
1743 #[doc = r" Writes raw bits to the field"]
1744 #[inline]
1745 pub fn bit(self, value: bool) -> &'a mut W {
1746 const MASK: bool = true;
1747 const OFFSET: u8 = 12;
1748 self.w.bits &= !((MASK as u32) << OFFSET);
1749 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1750 self.w
1751 }
1752}
1753#[doc = "Values that can be written to the field `WP4`"]
1754pub enum WP4W {
1755 #[doc = "This peripheral allows write accesses."]
1756 _0,
1757 #[doc = "This peripheral is write protected."]
1758 _1,
1759}
1760impl WP4W {
1761 #[allow(missing_docs)]
1762 #[doc(hidden)]
1763 #[inline]
1764 pub fn _bits(&self) -> bool {
1765 match *self {
1766 WP4W::_0 => false,
1767 WP4W::_1 => true,
1768 }
1769 }
1770}
1771#[doc = r" Proxy"]
1772pub struct _WP4W<'a> {
1773 w: &'a mut W,
1774}
1775impl<'a> _WP4W<'a> {
1776 #[doc = r" Writes `variant` to the field"]
1777 #[inline]
1778 pub fn variant(self, variant: WP4W) -> &'a mut W {
1779 {
1780 self.bit(variant._bits())
1781 }
1782 }
1783 #[doc = "This peripheral allows write accesses."]
1784 #[inline]
1785 pub fn _0(self) -> &'a mut W {
1786 self.variant(WP4W::_0)
1787 }
1788 #[doc = "This peripheral is write protected."]
1789 #[inline]
1790 pub fn _1(self) -> &'a mut W {
1791 self.variant(WP4W::_1)
1792 }
1793 #[doc = r" Sets the field bit"]
1794 pub fn set_bit(self) -> &'a mut W {
1795 self.bit(true)
1796 }
1797 #[doc = r" Clears the field bit"]
1798 pub fn clear_bit(self) -> &'a mut W {
1799 self.bit(false)
1800 }
1801 #[doc = r" Writes raw bits to the field"]
1802 #[inline]
1803 pub fn bit(self, value: bool) -> &'a mut W {
1804 const MASK: bool = true;
1805 const OFFSET: u8 = 13;
1806 self.w.bits &= !((MASK as u32) << OFFSET);
1807 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1808 self.w
1809 }
1810}
1811#[doc = "Values that can be written to the field `SP4`"]
1812pub enum SP4W {
1813 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1814 _0,
1815 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1816 _1,
1817}
1818impl SP4W {
1819 #[allow(missing_docs)]
1820 #[doc(hidden)]
1821 #[inline]
1822 pub fn _bits(&self) -> bool {
1823 match *self {
1824 SP4W::_0 => false,
1825 SP4W::_1 => true,
1826 }
1827 }
1828}
1829#[doc = r" Proxy"]
1830pub struct _SP4W<'a> {
1831 w: &'a mut W,
1832}
1833impl<'a> _SP4W<'a> {
1834 #[doc = r" Writes `variant` to the field"]
1835 #[inline]
1836 pub fn variant(self, variant: SP4W) -> &'a mut W {
1837 {
1838 self.bit(variant._bits())
1839 }
1840 }
1841 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1842 #[inline]
1843 pub fn _0(self) -> &'a mut W {
1844 self.variant(SP4W::_0)
1845 }
1846 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1847 #[inline]
1848 pub fn _1(self) -> &'a mut W {
1849 self.variant(SP4W::_1)
1850 }
1851 #[doc = r" Sets the field bit"]
1852 pub fn set_bit(self) -> &'a mut W {
1853 self.bit(true)
1854 }
1855 #[doc = r" Clears the field bit"]
1856 pub fn clear_bit(self) -> &'a mut W {
1857 self.bit(false)
1858 }
1859 #[doc = r" Writes raw bits to the field"]
1860 #[inline]
1861 pub fn bit(self, value: bool) -> &'a mut W {
1862 const MASK: bool = true;
1863 const OFFSET: u8 = 14;
1864 self.w.bits &= !((MASK as u32) << OFFSET);
1865 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1866 self.w
1867 }
1868}
1869#[doc = "Values that can be written to the field `TP3`"]
1870pub enum TP3W {
1871 #[doc = "Accesses from an untrusted master are allowed."]
1872 _0,
1873 #[doc = "Accesses from an untrusted master are not allowed."]
1874 _1,
1875}
1876impl TP3W {
1877 #[allow(missing_docs)]
1878 #[doc(hidden)]
1879 #[inline]
1880 pub fn _bits(&self) -> bool {
1881 match *self {
1882 TP3W::_0 => false,
1883 TP3W::_1 => true,
1884 }
1885 }
1886}
1887#[doc = r" Proxy"]
1888pub struct _TP3W<'a> {
1889 w: &'a mut W,
1890}
1891impl<'a> _TP3W<'a> {
1892 #[doc = r" Writes `variant` to the field"]
1893 #[inline]
1894 pub fn variant(self, variant: TP3W) -> &'a mut W {
1895 {
1896 self.bit(variant._bits())
1897 }
1898 }
1899 #[doc = "Accesses from an untrusted master are allowed."]
1900 #[inline]
1901 pub fn _0(self) -> &'a mut W {
1902 self.variant(TP3W::_0)
1903 }
1904 #[doc = "Accesses from an untrusted master are not allowed."]
1905 #[inline]
1906 pub fn _1(self) -> &'a mut W {
1907 self.variant(TP3W::_1)
1908 }
1909 #[doc = r" Sets the field bit"]
1910 pub fn set_bit(self) -> &'a mut W {
1911 self.bit(true)
1912 }
1913 #[doc = r" Clears the field bit"]
1914 pub fn clear_bit(self) -> &'a mut W {
1915 self.bit(false)
1916 }
1917 #[doc = r" Writes raw bits to the field"]
1918 #[inline]
1919 pub fn bit(self, value: bool) -> &'a mut W {
1920 const MASK: bool = true;
1921 const OFFSET: u8 = 16;
1922 self.w.bits &= !((MASK as u32) << OFFSET);
1923 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1924 self.w
1925 }
1926}
1927#[doc = "Values that can be written to the field `WP3`"]
1928pub enum WP3W {
1929 #[doc = "This peripheral allows write accesses."]
1930 _0,
1931 #[doc = "This peripheral is write protected."]
1932 _1,
1933}
1934impl WP3W {
1935 #[allow(missing_docs)]
1936 #[doc(hidden)]
1937 #[inline]
1938 pub fn _bits(&self) -> bool {
1939 match *self {
1940 WP3W::_0 => false,
1941 WP3W::_1 => true,
1942 }
1943 }
1944}
1945#[doc = r" Proxy"]
1946pub struct _WP3W<'a> {
1947 w: &'a mut W,
1948}
1949impl<'a> _WP3W<'a> {
1950 #[doc = r" Writes `variant` to the field"]
1951 #[inline]
1952 pub fn variant(self, variant: WP3W) -> &'a mut W {
1953 {
1954 self.bit(variant._bits())
1955 }
1956 }
1957 #[doc = "This peripheral allows write accesses."]
1958 #[inline]
1959 pub fn _0(self) -> &'a mut W {
1960 self.variant(WP3W::_0)
1961 }
1962 #[doc = "This peripheral is write protected."]
1963 #[inline]
1964 pub fn _1(self) -> &'a mut W {
1965 self.variant(WP3W::_1)
1966 }
1967 #[doc = r" Sets the field bit"]
1968 pub fn set_bit(self) -> &'a mut W {
1969 self.bit(true)
1970 }
1971 #[doc = r" Clears the field bit"]
1972 pub fn clear_bit(self) -> &'a mut W {
1973 self.bit(false)
1974 }
1975 #[doc = r" Writes raw bits to the field"]
1976 #[inline]
1977 pub fn bit(self, value: bool) -> &'a mut W {
1978 const MASK: bool = true;
1979 const OFFSET: u8 = 17;
1980 self.w.bits &= !((MASK as u32) << OFFSET);
1981 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1982 self.w
1983 }
1984}
1985#[doc = "Values that can be written to the field `SP3`"]
1986pub enum SP3W {
1987 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1988 _0,
1989 #[doc = "This peripheral requires supervisor privilege level for accesses."]
1990 _1,
1991}
1992impl SP3W {
1993 #[allow(missing_docs)]
1994 #[doc(hidden)]
1995 #[inline]
1996 pub fn _bits(&self) -> bool {
1997 match *self {
1998 SP3W::_0 => false,
1999 SP3W::_1 => true,
2000 }
2001 }
2002}
2003#[doc = r" Proxy"]
2004pub struct _SP3W<'a> {
2005 w: &'a mut W,
2006}
2007impl<'a> _SP3W<'a> {
2008 #[doc = r" Writes `variant` to the field"]
2009 #[inline]
2010 pub fn variant(self, variant: SP3W) -> &'a mut W {
2011 {
2012 self.bit(variant._bits())
2013 }
2014 }
2015 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2016 #[inline]
2017 pub fn _0(self) -> &'a mut W {
2018 self.variant(SP3W::_0)
2019 }
2020 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2021 #[inline]
2022 pub fn _1(self) -> &'a mut W {
2023 self.variant(SP3W::_1)
2024 }
2025 #[doc = r" Sets the field bit"]
2026 pub fn set_bit(self) -> &'a mut W {
2027 self.bit(true)
2028 }
2029 #[doc = r" Clears the field bit"]
2030 pub fn clear_bit(self) -> &'a mut W {
2031 self.bit(false)
2032 }
2033 #[doc = r" Writes raw bits to the field"]
2034 #[inline]
2035 pub fn bit(self, value: bool) -> &'a mut W {
2036 const MASK: bool = true;
2037 const OFFSET: u8 = 18;
2038 self.w.bits &= !((MASK as u32) << OFFSET);
2039 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2040 self.w
2041 }
2042}
2043#[doc = "Values that can be written to the field `TP2`"]
2044pub enum TP2W {
2045 #[doc = "Accesses from an untrusted master are allowed."]
2046 _0,
2047 #[doc = "Accesses from an untrusted master are not allowed."]
2048 _1,
2049}
2050impl TP2W {
2051 #[allow(missing_docs)]
2052 #[doc(hidden)]
2053 #[inline]
2054 pub fn _bits(&self) -> bool {
2055 match *self {
2056 TP2W::_0 => false,
2057 TP2W::_1 => true,
2058 }
2059 }
2060}
2061#[doc = r" Proxy"]
2062pub struct _TP2W<'a> {
2063 w: &'a mut W,
2064}
2065impl<'a> _TP2W<'a> {
2066 #[doc = r" Writes `variant` to the field"]
2067 #[inline]
2068 pub fn variant(self, variant: TP2W) -> &'a mut W {
2069 {
2070 self.bit(variant._bits())
2071 }
2072 }
2073 #[doc = "Accesses from an untrusted master are allowed."]
2074 #[inline]
2075 pub fn _0(self) -> &'a mut W {
2076 self.variant(TP2W::_0)
2077 }
2078 #[doc = "Accesses from an untrusted master are not allowed."]
2079 #[inline]
2080 pub fn _1(self) -> &'a mut W {
2081 self.variant(TP2W::_1)
2082 }
2083 #[doc = r" Sets the field bit"]
2084 pub fn set_bit(self) -> &'a mut W {
2085 self.bit(true)
2086 }
2087 #[doc = r" Clears the field bit"]
2088 pub fn clear_bit(self) -> &'a mut W {
2089 self.bit(false)
2090 }
2091 #[doc = r" Writes raw bits to the field"]
2092 #[inline]
2093 pub fn bit(self, value: bool) -> &'a mut W {
2094 const MASK: bool = true;
2095 const OFFSET: u8 = 20;
2096 self.w.bits &= !((MASK as u32) << OFFSET);
2097 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2098 self.w
2099 }
2100}
2101#[doc = "Values that can be written to the field `WP2`"]
2102pub enum WP2W {
2103 #[doc = "This peripheral allows write accesses."]
2104 _0,
2105 #[doc = "This peripheral is write protected."]
2106 _1,
2107}
2108impl WP2W {
2109 #[allow(missing_docs)]
2110 #[doc(hidden)]
2111 #[inline]
2112 pub fn _bits(&self) -> bool {
2113 match *self {
2114 WP2W::_0 => false,
2115 WP2W::_1 => true,
2116 }
2117 }
2118}
2119#[doc = r" Proxy"]
2120pub struct _WP2W<'a> {
2121 w: &'a mut W,
2122}
2123impl<'a> _WP2W<'a> {
2124 #[doc = r" Writes `variant` to the field"]
2125 #[inline]
2126 pub fn variant(self, variant: WP2W) -> &'a mut W {
2127 {
2128 self.bit(variant._bits())
2129 }
2130 }
2131 #[doc = "This peripheral allows write accesses."]
2132 #[inline]
2133 pub fn _0(self) -> &'a mut W {
2134 self.variant(WP2W::_0)
2135 }
2136 #[doc = "This peripheral is write protected."]
2137 #[inline]
2138 pub fn _1(self) -> &'a mut W {
2139 self.variant(WP2W::_1)
2140 }
2141 #[doc = r" Sets the field bit"]
2142 pub fn set_bit(self) -> &'a mut W {
2143 self.bit(true)
2144 }
2145 #[doc = r" Clears the field bit"]
2146 pub fn clear_bit(self) -> &'a mut W {
2147 self.bit(false)
2148 }
2149 #[doc = r" Writes raw bits to the field"]
2150 #[inline]
2151 pub fn bit(self, value: bool) -> &'a mut W {
2152 const MASK: bool = true;
2153 const OFFSET: u8 = 21;
2154 self.w.bits &= !((MASK as u32) << OFFSET);
2155 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2156 self.w
2157 }
2158}
2159#[doc = "Values that can be written to the field `SP2`"]
2160pub enum SP2W {
2161 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2162 _0,
2163 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2164 _1,
2165}
2166impl SP2W {
2167 #[allow(missing_docs)]
2168 #[doc(hidden)]
2169 #[inline]
2170 pub fn _bits(&self) -> bool {
2171 match *self {
2172 SP2W::_0 => false,
2173 SP2W::_1 => true,
2174 }
2175 }
2176}
2177#[doc = r" Proxy"]
2178pub struct _SP2W<'a> {
2179 w: &'a mut W,
2180}
2181impl<'a> _SP2W<'a> {
2182 #[doc = r" Writes `variant` to the field"]
2183 #[inline]
2184 pub fn variant(self, variant: SP2W) -> &'a mut W {
2185 {
2186 self.bit(variant._bits())
2187 }
2188 }
2189 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2190 #[inline]
2191 pub fn _0(self) -> &'a mut W {
2192 self.variant(SP2W::_0)
2193 }
2194 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2195 #[inline]
2196 pub fn _1(self) -> &'a mut W {
2197 self.variant(SP2W::_1)
2198 }
2199 #[doc = r" Sets the field bit"]
2200 pub fn set_bit(self) -> &'a mut W {
2201 self.bit(true)
2202 }
2203 #[doc = r" Clears the field bit"]
2204 pub fn clear_bit(self) -> &'a mut W {
2205 self.bit(false)
2206 }
2207 #[doc = r" Writes raw bits to the field"]
2208 #[inline]
2209 pub fn bit(self, value: bool) -> &'a mut W {
2210 const MASK: bool = true;
2211 const OFFSET: u8 = 22;
2212 self.w.bits &= !((MASK as u32) << OFFSET);
2213 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2214 self.w
2215 }
2216}
2217#[doc = "Values that can be written to the field `TP1`"]
2218pub enum TP1W {
2219 #[doc = "Accesses from an untrusted master are allowed."]
2220 _0,
2221 #[doc = "Accesses from an untrusted master are not allowed."]
2222 _1,
2223}
2224impl TP1W {
2225 #[allow(missing_docs)]
2226 #[doc(hidden)]
2227 #[inline]
2228 pub fn _bits(&self) -> bool {
2229 match *self {
2230 TP1W::_0 => false,
2231 TP1W::_1 => true,
2232 }
2233 }
2234}
2235#[doc = r" Proxy"]
2236pub struct _TP1W<'a> {
2237 w: &'a mut W,
2238}
2239impl<'a> _TP1W<'a> {
2240 #[doc = r" Writes `variant` to the field"]
2241 #[inline]
2242 pub fn variant(self, variant: TP1W) -> &'a mut W {
2243 {
2244 self.bit(variant._bits())
2245 }
2246 }
2247 #[doc = "Accesses from an untrusted master are allowed."]
2248 #[inline]
2249 pub fn _0(self) -> &'a mut W {
2250 self.variant(TP1W::_0)
2251 }
2252 #[doc = "Accesses from an untrusted master are not allowed."]
2253 #[inline]
2254 pub fn _1(self) -> &'a mut W {
2255 self.variant(TP1W::_1)
2256 }
2257 #[doc = r" Sets the field bit"]
2258 pub fn set_bit(self) -> &'a mut W {
2259 self.bit(true)
2260 }
2261 #[doc = r" Clears the field bit"]
2262 pub fn clear_bit(self) -> &'a mut W {
2263 self.bit(false)
2264 }
2265 #[doc = r" Writes raw bits to the field"]
2266 #[inline]
2267 pub fn bit(self, value: bool) -> &'a mut W {
2268 const MASK: bool = true;
2269 const OFFSET: u8 = 24;
2270 self.w.bits &= !((MASK as u32) << OFFSET);
2271 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2272 self.w
2273 }
2274}
2275#[doc = "Values that can be written to the field `WP1`"]
2276pub enum WP1W {
2277 #[doc = "This peripheral allows write accesses."]
2278 _0,
2279 #[doc = "This peripheral is write protected."]
2280 _1,
2281}
2282impl WP1W {
2283 #[allow(missing_docs)]
2284 #[doc(hidden)]
2285 #[inline]
2286 pub fn _bits(&self) -> bool {
2287 match *self {
2288 WP1W::_0 => false,
2289 WP1W::_1 => true,
2290 }
2291 }
2292}
2293#[doc = r" Proxy"]
2294pub struct _WP1W<'a> {
2295 w: &'a mut W,
2296}
2297impl<'a> _WP1W<'a> {
2298 #[doc = r" Writes `variant` to the field"]
2299 #[inline]
2300 pub fn variant(self, variant: WP1W) -> &'a mut W {
2301 {
2302 self.bit(variant._bits())
2303 }
2304 }
2305 #[doc = "This peripheral allows write accesses."]
2306 #[inline]
2307 pub fn _0(self) -> &'a mut W {
2308 self.variant(WP1W::_0)
2309 }
2310 #[doc = "This peripheral is write protected."]
2311 #[inline]
2312 pub fn _1(self) -> &'a mut W {
2313 self.variant(WP1W::_1)
2314 }
2315 #[doc = r" Sets the field bit"]
2316 pub fn set_bit(self) -> &'a mut W {
2317 self.bit(true)
2318 }
2319 #[doc = r" Clears the field bit"]
2320 pub fn clear_bit(self) -> &'a mut W {
2321 self.bit(false)
2322 }
2323 #[doc = r" Writes raw bits to the field"]
2324 #[inline]
2325 pub fn bit(self, value: bool) -> &'a mut W {
2326 const MASK: bool = true;
2327 const OFFSET: u8 = 25;
2328 self.w.bits &= !((MASK as u32) << OFFSET);
2329 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2330 self.w
2331 }
2332}
2333#[doc = "Values that can be written to the field `SP1`"]
2334pub enum SP1W {
2335 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2336 _0,
2337 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2338 _1,
2339}
2340impl SP1W {
2341 #[allow(missing_docs)]
2342 #[doc(hidden)]
2343 #[inline]
2344 pub fn _bits(&self) -> bool {
2345 match *self {
2346 SP1W::_0 => false,
2347 SP1W::_1 => true,
2348 }
2349 }
2350}
2351#[doc = r" Proxy"]
2352pub struct _SP1W<'a> {
2353 w: &'a mut W,
2354}
2355impl<'a> _SP1W<'a> {
2356 #[doc = r" Writes `variant` to the field"]
2357 #[inline]
2358 pub fn variant(self, variant: SP1W) -> &'a mut W {
2359 {
2360 self.bit(variant._bits())
2361 }
2362 }
2363 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2364 #[inline]
2365 pub fn _0(self) -> &'a mut W {
2366 self.variant(SP1W::_0)
2367 }
2368 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2369 #[inline]
2370 pub fn _1(self) -> &'a mut W {
2371 self.variant(SP1W::_1)
2372 }
2373 #[doc = r" Sets the field bit"]
2374 pub fn set_bit(self) -> &'a mut W {
2375 self.bit(true)
2376 }
2377 #[doc = r" Clears the field bit"]
2378 pub fn clear_bit(self) -> &'a mut W {
2379 self.bit(false)
2380 }
2381 #[doc = r" Writes raw bits to the field"]
2382 #[inline]
2383 pub fn bit(self, value: bool) -> &'a mut W {
2384 const MASK: bool = true;
2385 const OFFSET: u8 = 26;
2386 self.w.bits &= !((MASK as u32) << OFFSET);
2387 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2388 self.w
2389 }
2390}
2391#[doc = "Values that can be written to the field `TP0`"]
2392pub enum TP0W {
2393 #[doc = "Accesses from an untrusted master are allowed."]
2394 _0,
2395 #[doc = "Accesses from an untrusted master are not allowed."]
2396 _1,
2397}
2398impl TP0W {
2399 #[allow(missing_docs)]
2400 #[doc(hidden)]
2401 #[inline]
2402 pub fn _bits(&self) -> bool {
2403 match *self {
2404 TP0W::_0 => false,
2405 TP0W::_1 => true,
2406 }
2407 }
2408}
2409#[doc = r" Proxy"]
2410pub struct _TP0W<'a> {
2411 w: &'a mut W,
2412}
2413impl<'a> _TP0W<'a> {
2414 #[doc = r" Writes `variant` to the field"]
2415 #[inline]
2416 pub fn variant(self, variant: TP0W) -> &'a mut W {
2417 {
2418 self.bit(variant._bits())
2419 }
2420 }
2421 #[doc = "Accesses from an untrusted master are allowed."]
2422 #[inline]
2423 pub fn _0(self) -> &'a mut W {
2424 self.variant(TP0W::_0)
2425 }
2426 #[doc = "Accesses from an untrusted master are not allowed."]
2427 #[inline]
2428 pub fn _1(self) -> &'a mut W {
2429 self.variant(TP0W::_1)
2430 }
2431 #[doc = r" Sets the field bit"]
2432 pub fn set_bit(self) -> &'a mut W {
2433 self.bit(true)
2434 }
2435 #[doc = r" Clears the field bit"]
2436 pub fn clear_bit(self) -> &'a mut W {
2437 self.bit(false)
2438 }
2439 #[doc = r" Writes raw bits to the field"]
2440 #[inline]
2441 pub fn bit(self, value: bool) -> &'a mut W {
2442 const MASK: bool = true;
2443 const OFFSET: u8 = 28;
2444 self.w.bits &= !((MASK as u32) << OFFSET);
2445 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2446 self.w
2447 }
2448}
2449#[doc = "Values that can be written to the field `WP0`"]
2450pub enum WP0W {
2451 #[doc = "This peripheral allows write accesses."]
2452 _0,
2453 #[doc = "This peripheral is write protected."]
2454 _1,
2455}
2456impl WP0W {
2457 #[allow(missing_docs)]
2458 #[doc(hidden)]
2459 #[inline]
2460 pub fn _bits(&self) -> bool {
2461 match *self {
2462 WP0W::_0 => false,
2463 WP0W::_1 => true,
2464 }
2465 }
2466}
2467#[doc = r" Proxy"]
2468pub struct _WP0W<'a> {
2469 w: &'a mut W,
2470}
2471impl<'a> _WP0W<'a> {
2472 #[doc = r" Writes `variant` to the field"]
2473 #[inline]
2474 pub fn variant(self, variant: WP0W) -> &'a mut W {
2475 {
2476 self.bit(variant._bits())
2477 }
2478 }
2479 #[doc = "This peripheral allows write accesses."]
2480 #[inline]
2481 pub fn _0(self) -> &'a mut W {
2482 self.variant(WP0W::_0)
2483 }
2484 #[doc = "This peripheral is write protected."]
2485 #[inline]
2486 pub fn _1(self) -> &'a mut W {
2487 self.variant(WP0W::_1)
2488 }
2489 #[doc = r" Sets the field bit"]
2490 pub fn set_bit(self) -> &'a mut W {
2491 self.bit(true)
2492 }
2493 #[doc = r" Clears the field bit"]
2494 pub fn clear_bit(self) -> &'a mut W {
2495 self.bit(false)
2496 }
2497 #[doc = r" Writes raw bits to the field"]
2498 #[inline]
2499 pub fn bit(self, value: bool) -> &'a mut W {
2500 const MASK: bool = true;
2501 const OFFSET: u8 = 29;
2502 self.w.bits &= !((MASK as u32) << OFFSET);
2503 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2504 self.w
2505 }
2506}
2507#[doc = "Values that can be written to the field `SP0`"]
2508pub enum SP0W {
2509 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2510 _0,
2511 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2512 _1,
2513}
2514impl SP0W {
2515 #[allow(missing_docs)]
2516 #[doc(hidden)]
2517 #[inline]
2518 pub fn _bits(&self) -> bool {
2519 match *self {
2520 SP0W::_0 => false,
2521 SP0W::_1 => true,
2522 }
2523 }
2524}
2525#[doc = r" Proxy"]
2526pub struct _SP0W<'a> {
2527 w: &'a mut W,
2528}
2529impl<'a> _SP0W<'a> {
2530 #[doc = r" Writes `variant` to the field"]
2531 #[inline]
2532 pub fn variant(self, variant: SP0W) -> &'a mut W {
2533 {
2534 self.bit(variant._bits())
2535 }
2536 }
2537 #[doc = "This peripheral does not require supervisor privilege level for accesses."]
2538 #[inline]
2539 pub fn _0(self) -> &'a mut W {
2540 self.variant(SP0W::_0)
2541 }
2542 #[doc = "This peripheral requires supervisor privilege level for accesses."]
2543 #[inline]
2544 pub fn _1(self) -> &'a mut W {
2545 self.variant(SP0W::_1)
2546 }
2547 #[doc = r" Sets the field bit"]
2548 pub fn set_bit(self) -> &'a mut W {
2549 self.bit(true)
2550 }
2551 #[doc = r" Clears the field bit"]
2552 pub fn clear_bit(self) -> &'a mut W {
2553 self.bit(false)
2554 }
2555 #[doc = r" Writes raw bits to the field"]
2556 #[inline]
2557 pub fn bit(self, value: bool) -> &'a mut W {
2558 const MASK: bool = true;
2559 const OFFSET: u8 = 30;
2560 self.w.bits &= !((MASK as u32) << OFFSET);
2561 self.w.bits |= ((value & MASK) as u32) << OFFSET;
2562 self.w
2563 }
2564}
2565impl R {
2566 #[doc = r" Value of the register as raw bits"]
2567 #[inline]
2568 pub fn bits(&self) -> u32 {
2569 self.bits
2570 }
2571 #[doc = "Bit 0 - Trusted Protect"]
2572 #[inline]
2573 pub fn tp7(&self) -> TP7R {
2574 TP7R::_from({
2575 const MASK: bool = true;
2576 const OFFSET: u8 = 0;
2577 ((self.bits >> OFFSET) & MASK as u32) != 0
2578 })
2579 }
2580 #[doc = "Bit 1 - Write Protect"]
2581 #[inline]
2582 pub fn wp7(&self) -> WP7R {
2583 WP7R::_from({
2584 const MASK: bool = true;
2585 const OFFSET: u8 = 1;
2586 ((self.bits >> OFFSET) & MASK as u32) != 0
2587 })
2588 }
2589 #[doc = "Bit 2 - Supervisor Protect"]
2590 #[inline]
2591 pub fn sp7(&self) -> SP7R {
2592 SP7R::_from({
2593 const MASK: bool = true;
2594 const OFFSET: u8 = 2;
2595 ((self.bits >> OFFSET) & MASK as u32) != 0
2596 })
2597 }
2598 #[doc = "Bit 4 - Trusted Protect"]
2599 #[inline]
2600 pub fn tp6(&self) -> TP6R {
2601 TP6R::_from({
2602 const MASK: bool = true;
2603 const OFFSET: u8 = 4;
2604 ((self.bits >> OFFSET) & MASK as u32) != 0
2605 })
2606 }
2607 #[doc = "Bit 5 - Write Protect"]
2608 #[inline]
2609 pub fn wp6(&self) -> WP6R {
2610 WP6R::_from({
2611 const MASK: bool = true;
2612 const OFFSET: u8 = 5;
2613 ((self.bits >> OFFSET) & MASK as u32) != 0
2614 })
2615 }
2616 #[doc = "Bit 6 - Supervisor Protect"]
2617 #[inline]
2618 pub fn sp6(&self) -> SP6R {
2619 SP6R::_from({
2620 const MASK: bool = true;
2621 const OFFSET: u8 = 6;
2622 ((self.bits >> OFFSET) & MASK as u32) != 0
2623 })
2624 }
2625 #[doc = "Bit 8 - Trusted Protect"]
2626 #[inline]
2627 pub fn tp5(&self) -> TP5R {
2628 TP5R::_from({
2629 const MASK: bool = true;
2630 const OFFSET: u8 = 8;
2631 ((self.bits >> OFFSET) & MASK as u32) != 0
2632 })
2633 }
2634 #[doc = "Bit 9 - Write Protect"]
2635 #[inline]
2636 pub fn wp5(&self) -> WP5R {
2637 WP5R::_from({
2638 const MASK: bool = true;
2639 const OFFSET: u8 = 9;
2640 ((self.bits >> OFFSET) & MASK as u32) != 0
2641 })
2642 }
2643 #[doc = "Bit 10 - Supervisor Protect"]
2644 #[inline]
2645 pub fn sp5(&self) -> SP5R {
2646 SP5R::_from({
2647 const MASK: bool = true;
2648 const OFFSET: u8 = 10;
2649 ((self.bits >> OFFSET) & MASK as u32) != 0
2650 })
2651 }
2652 #[doc = "Bit 12 - Trusted Protect"]
2653 #[inline]
2654 pub fn tp4(&self) -> TP4R {
2655 TP4R::_from({
2656 const MASK: bool = true;
2657 const OFFSET: u8 = 12;
2658 ((self.bits >> OFFSET) & MASK as u32) != 0
2659 })
2660 }
2661 #[doc = "Bit 13 - Write Protect"]
2662 #[inline]
2663 pub fn wp4(&self) -> WP4R {
2664 WP4R::_from({
2665 const MASK: bool = true;
2666 const OFFSET: u8 = 13;
2667 ((self.bits >> OFFSET) & MASK as u32) != 0
2668 })
2669 }
2670 #[doc = "Bit 14 - Supervisor Protect"]
2671 #[inline]
2672 pub fn sp4(&self) -> SP4R {
2673 SP4R::_from({
2674 const MASK: bool = true;
2675 const OFFSET: u8 = 14;
2676 ((self.bits >> OFFSET) & MASK as u32) != 0
2677 })
2678 }
2679 #[doc = "Bit 16 - Trusted Protect"]
2680 #[inline]
2681 pub fn tp3(&self) -> TP3R {
2682 TP3R::_from({
2683 const MASK: bool = true;
2684 const OFFSET: u8 = 16;
2685 ((self.bits >> OFFSET) & MASK as u32) != 0
2686 })
2687 }
2688 #[doc = "Bit 17 - Write Protect"]
2689 #[inline]
2690 pub fn wp3(&self) -> WP3R {
2691 WP3R::_from({
2692 const MASK: bool = true;
2693 const OFFSET: u8 = 17;
2694 ((self.bits >> OFFSET) & MASK as u32) != 0
2695 })
2696 }
2697 #[doc = "Bit 18 - Supervisor Protect"]
2698 #[inline]
2699 pub fn sp3(&self) -> SP3R {
2700 SP3R::_from({
2701 const MASK: bool = true;
2702 const OFFSET: u8 = 18;
2703 ((self.bits >> OFFSET) & MASK as u32) != 0
2704 })
2705 }
2706 #[doc = "Bit 20 - Trusted Protect"]
2707 #[inline]
2708 pub fn tp2(&self) -> TP2R {
2709 TP2R::_from({
2710 const MASK: bool = true;
2711 const OFFSET: u8 = 20;
2712 ((self.bits >> OFFSET) & MASK as u32) != 0
2713 })
2714 }
2715 #[doc = "Bit 21 - Write Protect"]
2716 #[inline]
2717 pub fn wp2(&self) -> WP2R {
2718 WP2R::_from({
2719 const MASK: bool = true;
2720 const OFFSET: u8 = 21;
2721 ((self.bits >> OFFSET) & MASK as u32) != 0
2722 })
2723 }
2724 #[doc = "Bit 22 - Supervisor Protect"]
2725 #[inline]
2726 pub fn sp2(&self) -> SP2R {
2727 SP2R::_from({
2728 const MASK: bool = true;
2729 const OFFSET: u8 = 22;
2730 ((self.bits >> OFFSET) & MASK as u32) != 0
2731 })
2732 }
2733 #[doc = "Bit 24 - Trusted Protect"]
2734 #[inline]
2735 pub fn tp1(&self) -> TP1R {
2736 TP1R::_from({
2737 const MASK: bool = true;
2738 const OFFSET: u8 = 24;
2739 ((self.bits >> OFFSET) & MASK as u32) != 0
2740 })
2741 }
2742 #[doc = "Bit 25 - Write Protect"]
2743 #[inline]
2744 pub fn wp1(&self) -> WP1R {
2745 WP1R::_from({
2746 const MASK: bool = true;
2747 const OFFSET: u8 = 25;
2748 ((self.bits >> OFFSET) & MASK as u32) != 0
2749 })
2750 }
2751 #[doc = "Bit 26 - Supervisor Protect"]
2752 #[inline]
2753 pub fn sp1(&self) -> SP1R {
2754 SP1R::_from({
2755 const MASK: bool = true;
2756 const OFFSET: u8 = 26;
2757 ((self.bits >> OFFSET) & MASK as u32) != 0
2758 })
2759 }
2760 #[doc = "Bit 28 - Trusted Protect"]
2761 #[inline]
2762 pub fn tp0(&self) -> TP0R {
2763 TP0R::_from({
2764 const MASK: bool = true;
2765 const OFFSET: u8 = 28;
2766 ((self.bits >> OFFSET) & MASK as u32) != 0
2767 })
2768 }
2769 #[doc = "Bit 29 - Write Protect"]
2770 #[inline]
2771 pub fn wp0(&self) -> WP0R {
2772 WP0R::_from({
2773 const MASK: bool = true;
2774 const OFFSET: u8 = 29;
2775 ((self.bits >> OFFSET) & MASK as u32) != 0
2776 })
2777 }
2778 #[doc = "Bit 30 - Supervisor Protect"]
2779 #[inline]
2780 pub fn sp0(&self) -> SP0R {
2781 SP0R::_from({
2782 const MASK: bool = true;
2783 const OFFSET: u8 = 30;
2784 ((self.bits >> OFFSET) & MASK as u32) != 0
2785 })
2786 }
2787}
2788impl W {
2789 #[doc = r" Reset value of the register"]
2790 #[inline]
2791 pub fn reset_value() -> W {
2792 W { bits: 0 }
2793 }
2794 #[doc = r" Writes raw bits to the register"]
2795 #[inline]
2796 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
2797 self.bits = bits;
2798 self
2799 }
2800 #[doc = "Bit 0 - Trusted Protect"]
2801 #[inline]
2802 pub fn tp7(&mut self) -> _TP7W {
2803 _TP7W { w: self }
2804 }
2805 #[doc = "Bit 1 - Write Protect"]
2806 #[inline]
2807 pub fn wp7(&mut self) -> _WP7W {
2808 _WP7W { w: self }
2809 }
2810 #[doc = "Bit 2 - Supervisor Protect"]
2811 #[inline]
2812 pub fn sp7(&mut self) -> _SP7W {
2813 _SP7W { w: self }
2814 }
2815 #[doc = "Bit 4 - Trusted Protect"]
2816 #[inline]
2817 pub fn tp6(&mut self) -> _TP6W {
2818 _TP6W { w: self }
2819 }
2820 #[doc = "Bit 5 - Write Protect"]
2821 #[inline]
2822 pub fn wp6(&mut self) -> _WP6W {
2823 _WP6W { w: self }
2824 }
2825 #[doc = "Bit 6 - Supervisor Protect"]
2826 #[inline]
2827 pub fn sp6(&mut self) -> _SP6W {
2828 _SP6W { w: self }
2829 }
2830 #[doc = "Bit 8 - Trusted Protect"]
2831 #[inline]
2832 pub fn tp5(&mut self) -> _TP5W {
2833 _TP5W { w: self }
2834 }
2835 #[doc = "Bit 9 - Write Protect"]
2836 #[inline]
2837 pub fn wp5(&mut self) -> _WP5W {
2838 _WP5W { w: self }
2839 }
2840 #[doc = "Bit 10 - Supervisor Protect"]
2841 #[inline]
2842 pub fn sp5(&mut self) -> _SP5W {
2843 _SP5W { w: self }
2844 }
2845 #[doc = "Bit 12 - Trusted Protect"]
2846 #[inline]
2847 pub fn tp4(&mut self) -> _TP4W {
2848 _TP4W { w: self }
2849 }
2850 #[doc = "Bit 13 - Write Protect"]
2851 #[inline]
2852 pub fn wp4(&mut self) -> _WP4W {
2853 _WP4W { w: self }
2854 }
2855 #[doc = "Bit 14 - Supervisor Protect"]
2856 #[inline]
2857 pub fn sp4(&mut self) -> _SP4W {
2858 _SP4W { w: self }
2859 }
2860 #[doc = "Bit 16 - Trusted Protect"]
2861 #[inline]
2862 pub fn tp3(&mut self) -> _TP3W {
2863 _TP3W { w: self }
2864 }
2865 #[doc = "Bit 17 - Write Protect"]
2866 #[inline]
2867 pub fn wp3(&mut self) -> _WP3W {
2868 _WP3W { w: self }
2869 }
2870 #[doc = "Bit 18 - Supervisor Protect"]
2871 #[inline]
2872 pub fn sp3(&mut self) -> _SP3W {
2873 _SP3W { w: self }
2874 }
2875 #[doc = "Bit 20 - Trusted Protect"]
2876 #[inline]
2877 pub fn tp2(&mut self) -> _TP2W {
2878 _TP2W { w: self }
2879 }
2880 #[doc = "Bit 21 - Write Protect"]
2881 #[inline]
2882 pub fn wp2(&mut self) -> _WP2W {
2883 _WP2W { w: self }
2884 }
2885 #[doc = "Bit 22 - Supervisor Protect"]
2886 #[inline]
2887 pub fn sp2(&mut self) -> _SP2W {
2888 _SP2W { w: self }
2889 }
2890 #[doc = "Bit 24 - Trusted Protect"]
2891 #[inline]
2892 pub fn tp1(&mut self) -> _TP1W {
2893 _TP1W { w: self }
2894 }
2895 #[doc = "Bit 25 - Write Protect"]
2896 #[inline]
2897 pub fn wp1(&mut self) -> _WP1W {
2898 _WP1W { w: self }
2899 }
2900 #[doc = "Bit 26 - Supervisor Protect"]
2901 #[inline]
2902 pub fn sp1(&mut self) -> _SP1W {
2903 _SP1W { w: self }
2904 }
2905 #[doc = "Bit 28 - Trusted Protect"]
2906 #[inline]
2907 pub fn tp0(&mut self) -> _TP0W {
2908 _TP0W { w: self }
2909 }
2910 #[doc = "Bit 29 - Write Protect"]
2911 #[inline]
2912 pub fn wp0(&mut self) -> _WP0W {
2913 _WP0W { w: self }
2914 }
2915 #[doc = "Bit 30 - Supervisor Protect"]
2916 #[inline]
2917 pub fn sp0(&mut self) -> _SP0W {
2918 _SP0W { w: self }
2919 }
2920}