mk66f18/aips0/
pacrn.rs

1#[doc = "Reader of register PACRN"]
2pub type R = crate::R<u32, super::PACRN>;
3#[doc = "Writer for register PACRN"]
4pub type W = crate::W<u32, super::PACRN>;
5#[doc = "Register PACRN `reset()`'s with value 0"]
6impl crate::ResetValue for super::PACRN {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "Trusted Protect\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum TP7_A {
16    #[doc = "0: Accesses from an untrusted master are allowed."]
17    _0,
18    #[doc = "1: Accesses from an untrusted master are not allowed."]
19    _1,
20}
21impl From<TP7_A> for bool {
22    #[inline(always)]
23    fn from(variant: TP7_A) -> Self {
24        match variant {
25            TP7_A::_0 => false,
26            TP7_A::_1 => true,
27        }
28    }
29}
30#[doc = "Reader of field `TP7`"]
31pub type TP7_R = crate::R<bool, TP7_A>;
32impl TP7_R {
33    #[doc = r"Get enumerated values variant"]
34    #[inline(always)]
35    pub fn variant(&self) -> TP7_A {
36        match self.bits {
37            false => TP7_A::_0,
38            true => TP7_A::_1,
39        }
40    }
41    #[doc = "Checks if the value of the field is `_0`"]
42    #[inline(always)]
43    pub fn is_0(&self) -> bool {
44        *self == TP7_A::_0
45    }
46    #[doc = "Checks if the value of the field is `_1`"]
47    #[inline(always)]
48    pub fn is_1(&self) -> bool {
49        *self == TP7_A::_1
50    }
51}
52#[doc = "Write proxy for field `TP7`"]
53pub struct TP7_W<'a> {
54    w: &'a mut W,
55}
56impl<'a> TP7_W<'a> {
57    #[doc = r"Writes `variant` to the field"]
58    #[inline(always)]
59    pub fn variant(self, variant: TP7_A) -> &'a mut W {
60        {
61            self.bit(variant.into())
62        }
63    }
64    #[doc = "Accesses from an untrusted master are allowed."]
65    #[inline(always)]
66    pub fn _0(self) -> &'a mut W {
67        self.variant(TP7_A::_0)
68    }
69    #[doc = "Accesses from an untrusted master are not allowed."]
70    #[inline(always)]
71    pub fn _1(self) -> &'a mut W {
72        self.variant(TP7_A::_1)
73    }
74    #[doc = r"Sets the field bit"]
75    #[inline(always)]
76    pub fn set_bit(self) -> &'a mut W {
77        self.bit(true)
78    }
79    #[doc = r"Clears the field bit"]
80    #[inline(always)]
81    pub fn clear_bit(self) -> &'a mut W {
82        self.bit(false)
83    }
84    #[doc = r"Writes raw bits to the field"]
85    #[inline(always)]
86    pub fn bit(self, value: bool) -> &'a mut W {
87        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
88        self.w
89    }
90}
91#[doc = "Write Protect\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum WP7_A {
94    #[doc = "0: This peripheral allows write accesses."]
95    _0,
96    #[doc = "1: This peripheral is write protected."]
97    _1,
98}
99impl From<WP7_A> for bool {
100    #[inline(always)]
101    fn from(variant: WP7_A) -> Self {
102        match variant {
103            WP7_A::_0 => false,
104            WP7_A::_1 => true,
105        }
106    }
107}
108#[doc = "Reader of field `WP7`"]
109pub type WP7_R = crate::R<bool, WP7_A>;
110impl WP7_R {
111    #[doc = r"Get enumerated values variant"]
112    #[inline(always)]
113    pub fn variant(&self) -> WP7_A {
114        match self.bits {
115            false => WP7_A::_0,
116            true => WP7_A::_1,
117        }
118    }
119    #[doc = "Checks if the value of the field is `_0`"]
120    #[inline(always)]
121    pub fn is_0(&self) -> bool {
122        *self == WP7_A::_0
123    }
124    #[doc = "Checks if the value of the field is `_1`"]
125    #[inline(always)]
126    pub fn is_1(&self) -> bool {
127        *self == WP7_A::_1
128    }
129}
130#[doc = "Write proxy for field `WP7`"]
131pub struct WP7_W<'a> {
132    w: &'a mut W,
133}
134impl<'a> WP7_W<'a> {
135    #[doc = r"Writes `variant` to the field"]
136    #[inline(always)]
137    pub fn variant(self, variant: WP7_A) -> &'a mut W {
138        {
139            self.bit(variant.into())
140        }
141    }
142    #[doc = "This peripheral allows write accesses."]
143    #[inline(always)]
144    pub fn _0(self) -> &'a mut W {
145        self.variant(WP7_A::_0)
146    }
147    #[doc = "This peripheral is write protected."]
148    #[inline(always)]
149    pub fn _1(self) -> &'a mut W {
150        self.variant(WP7_A::_1)
151    }
152    #[doc = r"Sets the field bit"]
153    #[inline(always)]
154    pub fn set_bit(self) -> &'a mut W {
155        self.bit(true)
156    }
157    #[doc = r"Clears the field bit"]
158    #[inline(always)]
159    pub fn clear_bit(self) -> &'a mut W {
160        self.bit(false)
161    }
162    #[doc = r"Writes raw bits to the field"]
163    #[inline(always)]
164    pub fn bit(self, value: bool) -> &'a mut W {
165        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
166        self.w
167    }
168}
169#[doc = "Supervisor Protect\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum SP7_A {
172    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
173    _0,
174    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
175    _1,
176}
177impl From<SP7_A> for bool {
178    #[inline(always)]
179    fn from(variant: SP7_A) -> Self {
180        match variant {
181            SP7_A::_0 => false,
182            SP7_A::_1 => true,
183        }
184    }
185}
186#[doc = "Reader of field `SP7`"]
187pub type SP7_R = crate::R<bool, SP7_A>;
188impl SP7_R {
189    #[doc = r"Get enumerated values variant"]
190    #[inline(always)]
191    pub fn variant(&self) -> SP7_A {
192        match self.bits {
193            false => SP7_A::_0,
194            true => SP7_A::_1,
195        }
196    }
197    #[doc = "Checks if the value of the field is `_0`"]
198    #[inline(always)]
199    pub fn is_0(&self) -> bool {
200        *self == SP7_A::_0
201    }
202    #[doc = "Checks if the value of the field is `_1`"]
203    #[inline(always)]
204    pub fn is_1(&self) -> bool {
205        *self == SP7_A::_1
206    }
207}
208#[doc = "Write proxy for field `SP7`"]
209pub struct SP7_W<'a> {
210    w: &'a mut W,
211}
212impl<'a> SP7_W<'a> {
213    #[doc = r"Writes `variant` to the field"]
214    #[inline(always)]
215    pub fn variant(self, variant: SP7_A) -> &'a mut W {
216        {
217            self.bit(variant.into())
218        }
219    }
220    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
221    #[inline(always)]
222    pub fn _0(self) -> &'a mut W {
223        self.variant(SP7_A::_0)
224    }
225    #[doc = "This peripheral requires supervisor privilege level for accesses."]
226    #[inline(always)]
227    pub fn _1(self) -> &'a mut W {
228        self.variant(SP7_A::_1)
229    }
230    #[doc = r"Sets the field bit"]
231    #[inline(always)]
232    pub fn set_bit(self) -> &'a mut W {
233        self.bit(true)
234    }
235    #[doc = r"Clears the field bit"]
236    #[inline(always)]
237    pub fn clear_bit(self) -> &'a mut W {
238        self.bit(false)
239    }
240    #[doc = r"Writes raw bits to the field"]
241    #[inline(always)]
242    pub fn bit(self, value: bool) -> &'a mut W {
243        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
244        self.w
245    }
246}
247#[doc = "Trusted Protect\n\nValue on reset: 0"]
248#[derive(Clone, Copy, Debug, PartialEq)]
249pub enum TP6_A {
250    #[doc = "0: Accesses from an untrusted master are allowed."]
251    _0,
252    #[doc = "1: Accesses from an untrusted master are not allowed."]
253    _1,
254}
255impl From<TP6_A> for bool {
256    #[inline(always)]
257    fn from(variant: TP6_A) -> Self {
258        match variant {
259            TP6_A::_0 => false,
260            TP6_A::_1 => true,
261        }
262    }
263}
264#[doc = "Reader of field `TP6`"]
265pub type TP6_R = crate::R<bool, TP6_A>;
266impl TP6_R {
267    #[doc = r"Get enumerated values variant"]
268    #[inline(always)]
269    pub fn variant(&self) -> TP6_A {
270        match self.bits {
271            false => TP6_A::_0,
272            true => TP6_A::_1,
273        }
274    }
275    #[doc = "Checks if the value of the field is `_0`"]
276    #[inline(always)]
277    pub fn is_0(&self) -> bool {
278        *self == TP6_A::_0
279    }
280    #[doc = "Checks if the value of the field is `_1`"]
281    #[inline(always)]
282    pub fn is_1(&self) -> bool {
283        *self == TP6_A::_1
284    }
285}
286#[doc = "Write proxy for field `TP6`"]
287pub struct TP6_W<'a> {
288    w: &'a mut W,
289}
290impl<'a> TP6_W<'a> {
291    #[doc = r"Writes `variant` to the field"]
292    #[inline(always)]
293    pub fn variant(self, variant: TP6_A) -> &'a mut W {
294        {
295            self.bit(variant.into())
296        }
297    }
298    #[doc = "Accesses from an untrusted master are allowed."]
299    #[inline(always)]
300    pub fn _0(self) -> &'a mut W {
301        self.variant(TP6_A::_0)
302    }
303    #[doc = "Accesses from an untrusted master are not allowed."]
304    #[inline(always)]
305    pub fn _1(self) -> &'a mut W {
306        self.variant(TP6_A::_1)
307    }
308    #[doc = r"Sets the field bit"]
309    #[inline(always)]
310    pub fn set_bit(self) -> &'a mut W {
311        self.bit(true)
312    }
313    #[doc = r"Clears the field bit"]
314    #[inline(always)]
315    pub fn clear_bit(self) -> &'a mut W {
316        self.bit(false)
317    }
318    #[doc = r"Writes raw bits to the field"]
319    #[inline(always)]
320    pub fn bit(self, value: bool) -> &'a mut W {
321        self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
322        self.w
323    }
324}
325#[doc = "Write Protect\n\nValue on reset: 0"]
326#[derive(Clone, Copy, Debug, PartialEq)]
327pub enum WP6_A {
328    #[doc = "0: This peripheral allows write accesses."]
329    _0,
330    #[doc = "1: This peripheral is write protected."]
331    _1,
332}
333impl From<WP6_A> for bool {
334    #[inline(always)]
335    fn from(variant: WP6_A) -> Self {
336        match variant {
337            WP6_A::_0 => false,
338            WP6_A::_1 => true,
339        }
340    }
341}
342#[doc = "Reader of field `WP6`"]
343pub type WP6_R = crate::R<bool, WP6_A>;
344impl WP6_R {
345    #[doc = r"Get enumerated values variant"]
346    #[inline(always)]
347    pub fn variant(&self) -> WP6_A {
348        match self.bits {
349            false => WP6_A::_0,
350            true => WP6_A::_1,
351        }
352    }
353    #[doc = "Checks if the value of the field is `_0`"]
354    #[inline(always)]
355    pub fn is_0(&self) -> bool {
356        *self == WP6_A::_0
357    }
358    #[doc = "Checks if the value of the field is `_1`"]
359    #[inline(always)]
360    pub fn is_1(&self) -> bool {
361        *self == WP6_A::_1
362    }
363}
364#[doc = "Write proxy for field `WP6`"]
365pub struct WP6_W<'a> {
366    w: &'a mut W,
367}
368impl<'a> WP6_W<'a> {
369    #[doc = r"Writes `variant` to the field"]
370    #[inline(always)]
371    pub fn variant(self, variant: WP6_A) -> &'a mut W {
372        {
373            self.bit(variant.into())
374        }
375    }
376    #[doc = "This peripheral allows write accesses."]
377    #[inline(always)]
378    pub fn _0(self) -> &'a mut W {
379        self.variant(WP6_A::_0)
380    }
381    #[doc = "This peripheral is write protected."]
382    #[inline(always)]
383    pub fn _1(self) -> &'a mut W {
384        self.variant(WP6_A::_1)
385    }
386    #[doc = r"Sets the field bit"]
387    #[inline(always)]
388    pub fn set_bit(self) -> &'a mut W {
389        self.bit(true)
390    }
391    #[doc = r"Clears the field bit"]
392    #[inline(always)]
393    pub fn clear_bit(self) -> &'a mut W {
394        self.bit(false)
395    }
396    #[doc = r"Writes raw bits to the field"]
397    #[inline(always)]
398    pub fn bit(self, value: bool) -> &'a mut W {
399        self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
400        self.w
401    }
402}
403#[doc = "Supervisor Protect\n\nValue on reset: 0"]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub enum SP6_A {
406    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
407    _0,
408    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
409    _1,
410}
411impl From<SP6_A> for bool {
412    #[inline(always)]
413    fn from(variant: SP6_A) -> Self {
414        match variant {
415            SP6_A::_0 => false,
416            SP6_A::_1 => true,
417        }
418    }
419}
420#[doc = "Reader of field `SP6`"]
421pub type SP6_R = crate::R<bool, SP6_A>;
422impl SP6_R {
423    #[doc = r"Get enumerated values variant"]
424    #[inline(always)]
425    pub fn variant(&self) -> SP6_A {
426        match self.bits {
427            false => SP6_A::_0,
428            true => SP6_A::_1,
429        }
430    }
431    #[doc = "Checks if the value of the field is `_0`"]
432    #[inline(always)]
433    pub fn is_0(&self) -> bool {
434        *self == SP6_A::_0
435    }
436    #[doc = "Checks if the value of the field is `_1`"]
437    #[inline(always)]
438    pub fn is_1(&self) -> bool {
439        *self == SP6_A::_1
440    }
441}
442#[doc = "Write proxy for field `SP6`"]
443pub struct SP6_W<'a> {
444    w: &'a mut W,
445}
446impl<'a> SP6_W<'a> {
447    #[doc = r"Writes `variant` to the field"]
448    #[inline(always)]
449    pub fn variant(self, variant: SP6_A) -> &'a mut W {
450        {
451            self.bit(variant.into())
452        }
453    }
454    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
455    #[inline(always)]
456    pub fn _0(self) -> &'a mut W {
457        self.variant(SP6_A::_0)
458    }
459    #[doc = "This peripheral requires supervisor privilege level for accesses."]
460    #[inline(always)]
461    pub fn _1(self) -> &'a mut W {
462        self.variant(SP6_A::_1)
463    }
464    #[doc = r"Sets the field bit"]
465    #[inline(always)]
466    pub fn set_bit(self) -> &'a mut W {
467        self.bit(true)
468    }
469    #[doc = r"Clears the field bit"]
470    #[inline(always)]
471    pub fn clear_bit(self) -> &'a mut W {
472        self.bit(false)
473    }
474    #[doc = r"Writes raw bits to the field"]
475    #[inline(always)]
476    pub fn bit(self, value: bool) -> &'a mut W {
477        self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
478        self.w
479    }
480}
481#[doc = "Trusted Protect\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq)]
483pub enum TP5_A {
484    #[doc = "0: Accesses from an untrusted master are allowed."]
485    _0,
486    #[doc = "1: Accesses from an untrusted master are not allowed."]
487    _1,
488}
489impl From<TP5_A> for bool {
490    #[inline(always)]
491    fn from(variant: TP5_A) -> Self {
492        match variant {
493            TP5_A::_0 => false,
494            TP5_A::_1 => true,
495        }
496    }
497}
498#[doc = "Reader of field `TP5`"]
499pub type TP5_R = crate::R<bool, TP5_A>;
500impl TP5_R {
501    #[doc = r"Get enumerated values variant"]
502    #[inline(always)]
503    pub fn variant(&self) -> TP5_A {
504        match self.bits {
505            false => TP5_A::_0,
506            true => TP5_A::_1,
507        }
508    }
509    #[doc = "Checks if the value of the field is `_0`"]
510    #[inline(always)]
511    pub fn is_0(&self) -> bool {
512        *self == TP5_A::_0
513    }
514    #[doc = "Checks if the value of the field is `_1`"]
515    #[inline(always)]
516    pub fn is_1(&self) -> bool {
517        *self == TP5_A::_1
518    }
519}
520#[doc = "Write proxy for field `TP5`"]
521pub struct TP5_W<'a> {
522    w: &'a mut W,
523}
524impl<'a> TP5_W<'a> {
525    #[doc = r"Writes `variant` to the field"]
526    #[inline(always)]
527    pub fn variant(self, variant: TP5_A) -> &'a mut W {
528        {
529            self.bit(variant.into())
530        }
531    }
532    #[doc = "Accesses from an untrusted master are allowed."]
533    #[inline(always)]
534    pub fn _0(self) -> &'a mut W {
535        self.variant(TP5_A::_0)
536    }
537    #[doc = "Accesses from an untrusted master are not allowed."]
538    #[inline(always)]
539    pub fn _1(self) -> &'a mut W {
540        self.variant(TP5_A::_1)
541    }
542    #[doc = r"Sets the field bit"]
543    #[inline(always)]
544    pub fn set_bit(self) -> &'a mut W {
545        self.bit(true)
546    }
547    #[doc = r"Clears the field bit"]
548    #[inline(always)]
549    pub fn clear_bit(self) -> &'a mut W {
550        self.bit(false)
551    }
552    #[doc = r"Writes raw bits to the field"]
553    #[inline(always)]
554    pub fn bit(self, value: bool) -> &'a mut W {
555        self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
556        self.w
557    }
558}
559#[doc = "Write Protect\n\nValue on reset: 0"]
560#[derive(Clone, Copy, Debug, PartialEq)]
561pub enum WP5_A {
562    #[doc = "0: This peripheral allows write accesses."]
563    _0,
564    #[doc = "1: This peripheral is write protected."]
565    _1,
566}
567impl From<WP5_A> for bool {
568    #[inline(always)]
569    fn from(variant: WP5_A) -> Self {
570        match variant {
571            WP5_A::_0 => false,
572            WP5_A::_1 => true,
573        }
574    }
575}
576#[doc = "Reader of field `WP5`"]
577pub type WP5_R = crate::R<bool, WP5_A>;
578impl WP5_R {
579    #[doc = r"Get enumerated values variant"]
580    #[inline(always)]
581    pub fn variant(&self) -> WP5_A {
582        match self.bits {
583            false => WP5_A::_0,
584            true => WP5_A::_1,
585        }
586    }
587    #[doc = "Checks if the value of the field is `_0`"]
588    #[inline(always)]
589    pub fn is_0(&self) -> bool {
590        *self == WP5_A::_0
591    }
592    #[doc = "Checks if the value of the field is `_1`"]
593    #[inline(always)]
594    pub fn is_1(&self) -> bool {
595        *self == WP5_A::_1
596    }
597}
598#[doc = "Write proxy for field `WP5`"]
599pub struct WP5_W<'a> {
600    w: &'a mut W,
601}
602impl<'a> WP5_W<'a> {
603    #[doc = r"Writes `variant` to the field"]
604    #[inline(always)]
605    pub fn variant(self, variant: WP5_A) -> &'a mut W {
606        {
607            self.bit(variant.into())
608        }
609    }
610    #[doc = "This peripheral allows write accesses."]
611    #[inline(always)]
612    pub fn _0(self) -> &'a mut W {
613        self.variant(WP5_A::_0)
614    }
615    #[doc = "This peripheral is write protected."]
616    #[inline(always)]
617    pub fn _1(self) -> &'a mut W {
618        self.variant(WP5_A::_1)
619    }
620    #[doc = r"Sets the field bit"]
621    #[inline(always)]
622    pub fn set_bit(self) -> &'a mut W {
623        self.bit(true)
624    }
625    #[doc = r"Clears the field bit"]
626    #[inline(always)]
627    pub fn clear_bit(self) -> &'a mut W {
628        self.bit(false)
629    }
630    #[doc = r"Writes raw bits to the field"]
631    #[inline(always)]
632    pub fn bit(self, value: bool) -> &'a mut W {
633        self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
634        self.w
635    }
636}
637#[doc = "Supervisor Protect\n\nValue on reset: 0"]
638#[derive(Clone, Copy, Debug, PartialEq)]
639pub enum SP5_A {
640    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
641    _0,
642    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
643    _1,
644}
645impl From<SP5_A> for bool {
646    #[inline(always)]
647    fn from(variant: SP5_A) -> Self {
648        match variant {
649            SP5_A::_0 => false,
650            SP5_A::_1 => true,
651        }
652    }
653}
654#[doc = "Reader of field `SP5`"]
655pub type SP5_R = crate::R<bool, SP5_A>;
656impl SP5_R {
657    #[doc = r"Get enumerated values variant"]
658    #[inline(always)]
659    pub fn variant(&self) -> SP5_A {
660        match self.bits {
661            false => SP5_A::_0,
662            true => SP5_A::_1,
663        }
664    }
665    #[doc = "Checks if the value of the field is `_0`"]
666    #[inline(always)]
667    pub fn is_0(&self) -> bool {
668        *self == SP5_A::_0
669    }
670    #[doc = "Checks if the value of the field is `_1`"]
671    #[inline(always)]
672    pub fn is_1(&self) -> bool {
673        *self == SP5_A::_1
674    }
675}
676#[doc = "Write proxy for field `SP5`"]
677pub struct SP5_W<'a> {
678    w: &'a mut W,
679}
680impl<'a> SP5_W<'a> {
681    #[doc = r"Writes `variant` to the field"]
682    #[inline(always)]
683    pub fn variant(self, variant: SP5_A) -> &'a mut W {
684        {
685            self.bit(variant.into())
686        }
687    }
688    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
689    #[inline(always)]
690    pub fn _0(self) -> &'a mut W {
691        self.variant(SP5_A::_0)
692    }
693    #[doc = "This peripheral requires supervisor privilege level for accesses."]
694    #[inline(always)]
695    pub fn _1(self) -> &'a mut W {
696        self.variant(SP5_A::_1)
697    }
698    #[doc = r"Sets the field bit"]
699    #[inline(always)]
700    pub fn set_bit(self) -> &'a mut W {
701        self.bit(true)
702    }
703    #[doc = r"Clears the field bit"]
704    #[inline(always)]
705    pub fn clear_bit(self) -> &'a mut W {
706        self.bit(false)
707    }
708    #[doc = r"Writes raw bits to the field"]
709    #[inline(always)]
710    pub fn bit(self, value: bool) -> &'a mut W {
711        self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
712        self.w
713    }
714}
715#[doc = "Trusted Protect\n\nValue on reset: 0"]
716#[derive(Clone, Copy, Debug, PartialEq)]
717pub enum TP4_A {
718    #[doc = "0: Accesses from an untrusted master are allowed."]
719    _0,
720    #[doc = "1: Accesses from an untrusted master are not allowed."]
721    _1,
722}
723impl From<TP4_A> for bool {
724    #[inline(always)]
725    fn from(variant: TP4_A) -> Self {
726        match variant {
727            TP4_A::_0 => false,
728            TP4_A::_1 => true,
729        }
730    }
731}
732#[doc = "Reader of field `TP4`"]
733pub type TP4_R = crate::R<bool, TP4_A>;
734impl TP4_R {
735    #[doc = r"Get enumerated values variant"]
736    #[inline(always)]
737    pub fn variant(&self) -> TP4_A {
738        match self.bits {
739            false => TP4_A::_0,
740            true => TP4_A::_1,
741        }
742    }
743    #[doc = "Checks if the value of the field is `_0`"]
744    #[inline(always)]
745    pub fn is_0(&self) -> bool {
746        *self == TP4_A::_0
747    }
748    #[doc = "Checks if the value of the field is `_1`"]
749    #[inline(always)]
750    pub fn is_1(&self) -> bool {
751        *self == TP4_A::_1
752    }
753}
754#[doc = "Write proxy for field `TP4`"]
755pub struct TP4_W<'a> {
756    w: &'a mut W,
757}
758impl<'a> TP4_W<'a> {
759    #[doc = r"Writes `variant` to the field"]
760    #[inline(always)]
761    pub fn variant(self, variant: TP4_A) -> &'a mut W {
762        {
763            self.bit(variant.into())
764        }
765    }
766    #[doc = "Accesses from an untrusted master are allowed."]
767    #[inline(always)]
768    pub fn _0(self) -> &'a mut W {
769        self.variant(TP4_A::_0)
770    }
771    #[doc = "Accesses from an untrusted master are not allowed."]
772    #[inline(always)]
773    pub fn _1(self) -> &'a mut W {
774        self.variant(TP4_A::_1)
775    }
776    #[doc = r"Sets the field bit"]
777    #[inline(always)]
778    pub fn set_bit(self) -> &'a mut W {
779        self.bit(true)
780    }
781    #[doc = r"Clears the field bit"]
782    #[inline(always)]
783    pub fn clear_bit(self) -> &'a mut W {
784        self.bit(false)
785    }
786    #[doc = r"Writes raw bits to the field"]
787    #[inline(always)]
788    pub fn bit(self, value: bool) -> &'a mut W {
789        self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
790        self.w
791    }
792}
793#[doc = "Write Protect\n\nValue on reset: 0"]
794#[derive(Clone, Copy, Debug, PartialEq)]
795pub enum WP4_A {
796    #[doc = "0: This peripheral allows write accesses."]
797    _0,
798    #[doc = "1: This peripheral is write protected."]
799    _1,
800}
801impl From<WP4_A> for bool {
802    #[inline(always)]
803    fn from(variant: WP4_A) -> Self {
804        match variant {
805            WP4_A::_0 => false,
806            WP4_A::_1 => true,
807        }
808    }
809}
810#[doc = "Reader of field `WP4`"]
811pub type WP4_R = crate::R<bool, WP4_A>;
812impl WP4_R {
813    #[doc = r"Get enumerated values variant"]
814    #[inline(always)]
815    pub fn variant(&self) -> WP4_A {
816        match self.bits {
817            false => WP4_A::_0,
818            true => WP4_A::_1,
819        }
820    }
821    #[doc = "Checks if the value of the field is `_0`"]
822    #[inline(always)]
823    pub fn is_0(&self) -> bool {
824        *self == WP4_A::_0
825    }
826    #[doc = "Checks if the value of the field is `_1`"]
827    #[inline(always)]
828    pub fn is_1(&self) -> bool {
829        *self == WP4_A::_1
830    }
831}
832#[doc = "Write proxy for field `WP4`"]
833pub struct WP4_W<'a> {
834    w: &'a mut W,
835}
836impl<'a> WP4_W<'a> {
837    #[doc = r"Writes `variant` to the field"]
838    #[inline(always)]
839    pub fn variant(self, variant: WP4_A) -> &'a mut W {
840        {
841            self.bit(variant.into())
842        }
843    }
844    #[doc = "This peripheral allows write accesses."]
845    #[inline(always)]
846    pub fn _0(self) -> &'a mut W {
847        self.variant(WP4_A::_0)
848    }
849    #[doc = "This peripheral is write protected."]
850    #[inline(always)]
851    pub fn _1(self) -> &'a mut W {
852        self.variant(WP4_A::_1)
853    }
854    #[doc = r"Sets the field bit"]
855    #[inline(always)]
856    pub fn set_bit(self) -> &'a mut W {
857        self.bit(true)
858    }
859    #[doc = r"Clears the field bit"]
860    #[inline(always)]
861    pub fn clear_bit(self) -> &'a mut W {
862        self.bit(false)
863    }
864    #[doc = r"Writes raw bits to the field"]
865    #[inline(always)]
866    pub fn bit(self, value: bool) -> &'a mut W {
867        self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
868        self.w
869    }
870}
871#[doc = "Supervisor Protect\n\nValue on reset: 0"]
872#[derive(Clone, Copy, Debug, PartialEq)]
873pub enum SP4_A {
874    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
875    _0,
876    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
877    _1,
878}
879impl From<SP4_A> for bool {
880    #[inline(always)]
881    fn from(variant: SP4_A) -> Self {
882        match variant {
883            SP4_A::_0 => false,
884            SP4_A::_1 => true,
885        }
886    }
887}
888#[doc = "Reader of field `SP4`"]
889pub type SP4_R = crate::R<bool, SP4_A>;
890impl SP4_R {
891    #[doc = r"Get enumerated values variant"]
892    #[inline(always)]
893    pub fn variant(&self) -> SP4_A {
894        match self.bits {
895            false => SP4_A::_0,
896            true => SP4_A::_1,
897        }
898    }
899    #[doc = "Checks if the value of the field is `_0`"]
900    #[inline(always)]
901    pub fn is_0(&self) -> bool {
902        *self == SP4_A::_0
903    }
904    #[doc = "Checks if the value of the field is `_1`"]
905    #[inline(always)]
906    pub fn is_1(&self) -> bool {
907        *self == SP4_A::_1
908    }
909}
910#[doc = "Write proxy for field `SP4`"]
911pub struct SP4_W<'a> {
912    w: &'a mut W,
913}
914impl<'a> SP4_W<'a> {
915    #[doc = r"Writes `variant` to the field"]
916    #[inline(always)]
917    pub fn variant(self, variant: SP4_A) -> &'a mut W {
918        {
919            self.bit(variant.into())
920        }
921    }
922    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
923    #[inline(always)]
924    pub fn _0(self) -> &'a mut W {
925        self.variant(SP4_A::_0)
926    }
927    #[doc = "This peripheral requires supervisor privilege level for accesses."]
928    #[inline(always)]
929    pub fn _1(self) -> &'a mut W {
930        self.variant(SP4_A::_1)
931    }
932    #[doc = r"Sets the field bit"]
933    #[inline(always)]
934    pub fn set_bit(self) -> &'a mut W {
935        self.bit(true)
936    }
937    #[doc = r"Clears the field bit"]
938    #[inline(always)]
939    pub fn clear_bit(self) -> &'a mut W {
940        self.bit(false)
941    }
942    #[doc = r"Writes raw bits to the field"]
943    #[inline(always)]
944    pub fn bit(self, value: bool) -> &'a mut W {
945        self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
946        self.w
947    }
948}
949#[doc = "Trusted Protect\n\nValue on reset: 0"]
950#[derive(Clone, Copy, Debug, PartialEq)]
951pub enum TP3_A {
952    #[doc = "0: Accesses from an untrusted master are allowed."]
953    _0,
954    #[doc = "1: Accesses from an untrusted master are not allowed."]
955    _1,
956}
957impl From<TP3_A> for bool {
958    #[inline(always)]
959    fn from(variant: TP3_A) -> Self {
960        match variant {
961            TP3_A::_0 => false,
962            TP3_A::_1 => true,
963        }
964    }
965}
966#[doc = "Reader of field `TP3`"]
967pub type TP3_R = crate::R<bool, TP3_A>;
968impl TP3_R {
969    #[doc = r"Get enumerated values variant"]
970    #[inline(always)]
971    pub fn variant(&self) -> TP3_A {
972        match self.bits {
973            false => TP3_A::_0,
974            true => TP3_A::_1,
975        }
976    }
977    #[doc = "Checks if the value of the field is `_0`"]
978    #[inline(always)]
979    pub fn is_0(&self) -> bool {
980        *self == TP3_A::_0
981    }
982    #[doc = "Checks if the value of the field is `_1`"]
983    #[inline(always)]
984    pub fn is_1(&self) -> bool {
985        *self == TP3_A::_1
986    }
987}
988#[doc = "Write proxy for field `TP3`"]
989pub struct TP3_W<'a> {
990    w: &'a mut W,
991}
992impl<'a> TP3_W<'a> {
993    #[doc = r"Writes `variant` to the field"]
994    #[inline(always)]
995    pub fn variant(self, variant: TP3_A) -> &'a mut W {
996        {
997            self.bit(variant.into())
998        }
999    }
1000    #[doc = "Accesses from an untrusted master are allowed."]
1001    #[inline(always)]
1002    pub fn _0(self) -> &'a mut W {
1003        self.variant(TP3_A::_0)
1004    }
1005    #[doc = "Accesses from an untrusted master are not allowed."]
1006    #[inline(always)]
1007    pub fn _1(self) -> &'a mut W {
1008        self.variant(TP3_A::_1)
1009    }
1010    #[doc = r"Sets the field bit"]
1011    #[inline(always)]
1012    pub fn set_bit(self) -> &'a mut W {
1013        self.bit(true)
1014    }
1015    #[doc = r"Clears the field bit"]
1016    #[inline(always)]
1017    pub fn clear_bit(self) -> &'a mut W {
1018        self.bit(false)
1019    }
1020    #[doc = r"Writes raw bits to the field"]
1021    #[inline(always)]
1022    pub fn bit(self, value: bool) -> &'a mut W {
1023        self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
1024        self.w
1025    }
1026}
1027#[doc = "Write Protect\n\nValue on reset: 0"]
1028#[derive(Clone, Copy, Debug, PartialEq)]
1029pub enum WP3_A {
1030    #[doc = "0: This peripheral allows write accesses."]
1031    _0,
1032    #[doc = "1: This peripheral is write protected."]
1033    _1,
1034}
1035impl From<WP3_A> for bool {
1036    #[inline(always)]
1037    fn from(variant: WP3_A) -> Self {
1038        match variant {
1039            WP3_A::_0 => false,
1040            WP3_A::_1 => true,
1041        }
1042    }
1043}
1044#[doc = "Reader of field `WP3`"]
1045pub type WP3_R = crate::R<bool, WP3_A>;
1046impl WP3_R {
1047    #[doc = r"Get enumerated values variant"]
1048    #[inline(always)]
1049    pub fn variant(&self) -> WP3_A {
1050        match self.bits {
1051            false => WP3_A::_0,
1052            true => WP3_A::_1,
1053        }
1054    }
1055    #[doc = "Checks if the value of the field is `_0`"]
1056    #[inline(always)]
1057    pub fn is_0(&self) -> bool {
1058        *self == WP3_A::_0
1059    }
1060    #[doc = "Checks if the value of the field is `_1`"]
1061    #[inline(always)]
1062    pub fn is_1(&self) -> bool {
1063        *self == WP3_A::_1
1064    }
1065}
1066#[doc = "Write proxy for field `WP3`"]
1067pub struct WP3_W<'a> {
1068    w: &'a mut W,
1069}
1070impl<'a> WP3_W<'a> {
1071    #[doc = r"Writes `variant` to the field"]
1072    #[inline(always)]
1073    pub fn variant(self, variant: WP3_A) -> &'a mut W {
1074        {
1075            self.bit(variant.into())
1076        }
1077    }
1078    #[doc = "This peripheral allows write accesses."]
1079    #[inline(always)]
1080    pub fn _0(self) -> &'a mut W {
1081        self.variant(WP3_A::_0)
1082    }
1083    #[doc = "This peripheral is write protected."]
1084    #[inline(always)]
1085    pub fn _1(self) -> &'a mut W {
1086        self.variant(WP3_A::_1)
1087    }
1088    #[doc = r"Sets the field bit"]
1089    #[inline(always)]
1090    pub fn set_bit(self) -> &'a mut W {
1091        self.bit(true)
1092    }
1093    #[doc = r"Clears the field bit"]
1094    #[inline(always)]
1095    pub fn clear_bit(self) -> &'a mut W {
1096        self.bit(false)
1097    }
1098    #[doc = r"Writes raw bits to the field"]
1099    #[inline(always)]
1100    pub fn bit(self, value: bool) -> &'a mut W {
1101        self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
1102        self.w
1103    }
1104}
1105#[doc = "Supervisor Protect\n\nValue on reset: 0"]
1106#[derive(Clone, Copy, Debug, PartialEq)]
1107pub enum SP3_A {
1108    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
1109    _0,
1110    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
1111    _1,
1112}
1113impl From<SP3_A> for bool {
1114    #[inline(always)]
1115    fn from(variant: SP3_A) -> Self {
1116        match variant {
1117            SP3_A::_0 => false,
1118            SP3_A::_1 => true,
1119        }
1120    }
1121}
1122#[doc = "Reader of field `SP3`"]
1123pub type SP3_R = crate::R<bool, SP3_A>;
1124impl SP3_R {
1125    #[doc = r"Get enumerated values variant"]
1126    #[inline(always)]
1127    pub fn variant(&self) -> SP3_A {
1128        match self.bits {
1129            false => SP3_A::_0,
1130            true => SP3_A::_1,
1131        }
1132    }
1133    #[doc = "Checks if the value of the field is `_0`"]
1134    #[inline(always)]
1135    pub fn is_0(&self) -> bool {
1136        *self == SP3_A::_0
1137    }
1138    #[doc = "Checks if the value of the field is `_1`"]
1139    #[inline(always)]
1140    pub fn is_1(&self) -> bool {
1141        *self == SP3_A::_1
1142    }
1143}
1144#[doc = "Write proxy for field `SP3`"]
1145pub struct SP3_W<'a> {
1146    w: &'a mut W,
1147}
1148impl<'a> SP3_W<'a> {
1149    #[doc = r"Writes `variant` to the field"]
1150    #[inline(always)]
1151    pub fn variant(self, variant: SP3_A) -> &'a mut W {
1152        {
1153            self.bit(variant.into())
1154        }
1155    }
1156    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1157    #[inline(always)]
1158    pub fn _0(self) -> &'a mut W {
1159        self.variant(SP3_A::_0)
1160    }
1161    #[doc = "This peripheral requires supervisor privilege level for accesses."]
1162    #[inline(always)]
1163    pub fn _1(self) -> &'a mut W {
1164        self.variant(SP3_A::_1)
1165    }
1166    #[doc = r"Sets the field bit"]
1167    #[inline(always)]
1168    pub fn set_bit(self) -> &'a mut W {
1169        self.bit(true)
1170    }
1171    #[doc = r"Clears the field bit"]
1172    #[inline(always)]
1173    pub fn clear_bit(self) -> &'a mut W {
1174        self.bit(false)
1175    }
1176    #[doc = r"Writes raw bits to the field"]
1177    #[inline(always)]
1178    pub fn bit(self, value: bool) -> &'a mut W {
1179        self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
1180        self.w
1181    }
1182}
1183#[doc = "Trusted Protect\n\nValue on reset: 0"]
1184#[derive(Clone, Copy, Debug, PartialEq)]
1185pub enum TP2_A {
1186    #[doc = "0: Accesses from an untrusted master are allowed."]
1187    _0,
1188    #[doc = "1: Accesses from an untrusted master are not allowed."]
1189    _1,
1190}
1191impl From<TP2_A> for bool {
1192    #[inline(always)]
1193    fn from(variant: TP2_A) -> Self {
1194        match variant {
1195            TP2_A::_0 => false,
1196            TP2_A::_1 => true,
1197        }
1198    }
1199}
1200#[doc = "Reader of field `TP2`"]
1201pub type TP2_R = crate::R<bool, TP2_A>;
1202impl TP2_R {
1203    #[doc = r"Get enumerated values variant"]
1204    #[inline(always)]
1205    pub fn variant(&self) -> TP2_A {
1206        match self.bits {
1207            false => TP2_A::_0,
1208            true => TP2_A::_1,
1209        }
1210    }
1211    #[doc = "Checks if the value of the field is `_0`"]
1212    #[inline(always)]
1213    pub fn is_0(&self) -> bool {
1214        *self == TP2_A::_0
1215    }
1216    #[doc = "Checks if the value of the field is `_1`"]
1217    #[inline(always)]
1218    pub fn is_1(&self) -> bool {
1219        *self == TP2_A::_1
1220    }
1221}
1222#[doc = "Write proxy for field `TP2`"]
1223pub struct TP2_W<'a> {
1224    w: &'a mut W,
1225}
1226impl<'a> TP2_W<'a> {
1227    #[doc = r"Writes `variant` to the field"]
1228    #[inline(always)]
1229    pub fn variant(self, variant: TP2_A) -> &'a mut W {
1230        {
1231            self.bit(variant.into())
1232        }
1233    }
1234    #[doc = "Accesses from an untrusted master are allowed."]
1235    #[inline(always)]
1236    pub fn _0(self) -> &'a mut W {
1237        self.variant(TP2_A::_0)
1238    }
1239    #[doc = "Accesses from an untrusted master are not allowed."]
1240    #[inline(always)]
1241    pub fn _1(self) -> &'a mut W {
1242        self.variant(TP2_A::_1)
1243    }
1244    #[doc = r"Sets the field bit"]
1245    #[inline(always)]
1246    pub fn set_bit(self) -> &'a mut W {
1247        self.bit(true)
1248    }
1249    #[doc = r"Clears the field bit"]
1250    #[inline(always)]
1251    pub fn clear_bit(self) -> &'a mut W {
1252        self.bit(false)
1253    }
1254    #[doc = r"Writes raw bits to the field"]
1255    #[inline(always)]
1256    pub fn bit(self, value: bool) -> &'a mut W {
1257        self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
1258        self.w
1259    }
1260}
1261#[doc = "Write Protect\n\nValue on reset: 0"]
1262#[derive(Clone, Copy, Debug, PartialEq)]
1263pub enum WP2_A {
1264    #[doc = "0: This peripheral allows write accesses."]
1265    _0,
1266    #[doc = "1: This peripheral is write protected."]
1267    _1,
1268}
1269impl From<WP2_A> for bool {
1270    #[inline(always)]
1271    fn from(variant: WP2_A) -> Self {
1272        match variant {
1273            WP2_A::_0 => false,
1274            WP2_A::_1 => true,
1275        }
1276    }
1277}
1278#[doc = "Reader of field `WP2`"]
1279pub type WP2_R = crate::R<bool, WP2_A>;
1280impl WP2_R {
1281    #[doc = r"Get enumerated values variant"]
1282    #[inline(always)]
1283    pub fn variant(&self) -> WP2_A {
1284        match self.bits {
1285            false => WP2_A::_0,
1286            true => WP2_A::_1,
1287        }
1288    }
1289    #[doc = "Checks if the value of the field is `_0`"]
1290    #[inline(always)]
1291    pub fn is_0(&self) -> bool {
1292        *self == WP2_A::_0
1293    }
1294    #[doc = "Checks if the value of the field is `_1`"]
1295    #[inline(always)]
1296    pub fn is_1(&self) -> bool {
1297        *self == WP2_A::_1
1298    }
1299}
1300#[doc = "Write proxy for field `WP2`"]
1301pub struct WP2_W<'a> {
1302    w: &'a mut W,
1303}
1304impl<'a> WP2_W<'a> {
1305    #[doc = r"Writes `variant` to the field"]
1306    #[inline(always)]
1307    pub fn variant(self, variant: WP2_A) -> &'a mut W {
1308        {
1309            self.bit(variant.into())
1310        }
1311    }
1312    #[doc = "This peripheral allows write accesses."]
1313    #[inline(always)]
1314    pub fn _0(self) -> &'a mut W {
1315        self.variant(WP2_A::_0)
1316    }
1317    #[doc = "This peripheral is write protected."]
1318    #[inline(always)]
1319    pub fn _1(self) -> &'a mut W {
1320        self.variant(WP2_A::_1)
1321    }
1322    #[doc = r"Sets the field bit"]
1323    #[inline(always)]
1324    pub fn set_bit(self) -> &'a mut W {
1325        self.bit(true)
1326    }
1327    #[doc = r"Clears the field bit"]
1328    #[inline(always)]
1329    pub fn clear_bit(self) -> &'a mut W {
1330        self.bit(false)
1331    }
1332    #[doc = r"Writes raw bits to the field"]
1333    #[inline(always)]
1334    pub fn bit(self, value: bool) -> &'a mut W {
1335        self.w.bits = (self.w.bits & !(0x01 << 21)) | (((value as u32) & 0x01) << 21);
1336        self.w
1337    }
1338}
1339#[doc = "Supervisor Protect\n\nValue on reset: 0"]
1340#[derive(Clone, Copy, Debug, PartialEq)]
1341pub enum SP2_A {
1342    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
1343    _0,
1344    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
1345    _1,
1346}
1347impl From<SP2_A> for bool {
1348    #[inline(always)]
1349    fn from(variant: SP2_A) -> Self {
1350        match variant {
1351            SP2_A::_0 => false,
1352            SP2_A::_1 => true,
1353        }
1354    }
1355}
1356#[doc = "Reader of field `SP2`"]
1357pub type SP2_R = crate::R<bool, SP2_A>;
1358impl SP2_R {
1359    #[doc = r"Get enumerated values variant"]
1360    #[inline(always)]
1361    pub fn variant(&self) -> SP2_A {
1362        match self.bits {
1363            false => SP2_A::_0,
1364            true => SP2_A::_1,
1365        }
1366    }
1367    #[doc = "Checks if the value of the field is `_0`"]
1368    #[inline(always)]
1369    pub fn is_0(&self) -> bool {
1370        *self == SP2_A::_0
1371    }
1372    #[doc = "Checks if the value of the field is `_1`"]
1373    #[inline(always)]
1374    pub fn is_1(&self) -> bool {
1375        *self == SP2_A::_1
1376    }
1377}
1378#[doc = "Write proxy for field `SP2`"]
1379pub struct SP2_W<'a> {
1380    w: &'a mut W,
1381}
1382impl<'a> SP2_W<'a> {
1383    #[doc = r"Writes `variant` to the field"]
1384    #[inline(always)]
1385    pub fn variant(self, variant: SP2_A) -> &'a mut W {
1386        {
1387            self.bit(variant.into())
1388        }
1389    }
1390    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1391    #[inline(always)]
1392    pub fn _0(self) -> &'a mut W {
1393        self.variant(SP2_A::_0)
1394    }
1395    #[doc = "This peripheral requires supervisor privilege level for accesses."]
1396    #[inline(always)]
1397    pub fn _1(self) -> &'a mut W {
1398        self.variant(SP2_A::_1)
1399    }
1400    #[doc = r"Sets the field bit"]
1401    #[inline(always)]
1402    pub fn set_bit(self) -> &'a mut W {
1403        self.bit(true)
1404    }
1405    #[doc = r"Clears the field bit"]
1406    #[inline(always)]
1407    pub fn clear_bit(self) -> &'a mut W {
1408        self.bit(false)
1409    }
1410    #[doc = r"Writes raw bits to the field"]
1411    #[inline(always)]
1412    pub fn bit(self, value: bool) -> &'a mut W {
1413        self.w.bits = (self.w.bits & !(0x01 << 22)) | (((value as u32) & 0x01) << 22);
1414        self.w
1415    }
1416}
1417#[doc = "Trusted Protect\n\nValue on reset: 0"]
1418#[derive(Clone, Copy, Debug, PartialEq)]
1419pub enum TP1_A {
1420    #[doc = "0: Accesses from an untrusted master are allowed."]
1421    _0,
1422    #[doc = "1: Accesses from an untrusted master are not allowed."]
1423    _1,
1424}
1425impl From<TP1_A> for bool {
1426    #[inline(always)]
1427    fn from(variant: TP1_A) -> Self {
1428        match variant {
1429            TP1_A::_0 => false,
1430            TP1_A::_1 => true,
1431        }
1432    }
1433}
1434#[doc = "Reader of field `TP1`"]
1435pub type TP1_R = crate::R<bool, TP1_A>;
1436impl TP1_R {
1437    #[doc = r"Get enumerated values variant"]
1438    #[inline(always)]
1439    pub fn variant(&self) -> TP1_A {
1440        match self.bits {
1441            false => TP1_A::_0,
1442            true => TP1_A::_1,
1443        }
1444    }
1445    #[doc = "Checks if the value of the field is `_0`"]
1446    #[inline(always)]
1447    pub fn is_0(&self) -> bool {
1448        *self == TP1_A::_0
1449    }
1450    #[doc = "Checks if the value of the field is `_1`"]
1451    #[inline(always)]
1452    pub fn is_1(&self) -> bool {
1453        *self == TP1_A::_1
1454    }
1455}
1456#[doc = "Write proxy for field `TP1`"]
1457pub struct TP1_W<'a> {
1458    w: &'a mut W,
1459}
1460impl<'a> TP1_W<'a> {
1461    #[doc = r"Writes `variant` to the field"]
1462    #[inline(always)]
1463    pub fn variant(self, variant: TP1_A) -> &'a mut W {
1464        {
1465            self.bit(variant.into())
1466        }
1467    }
1468    #[doc = "Accesses from an untrusted master are allowed."]
1469    #[inline(always)]
1470    pub fn _0(self) -> &'a mut W {
1471        self.variant(TP1_A::_0)
1472    }
1473    #[doc = "Accesses from an untrusted master are not allowed."]
1474    #[inline(always)]
1475    pub fn _1(self) -> &'a mut W {
1476        self.variant(TP1_A::_1)
1477    }
1478    #[doc = r"Sets the field bit"]
1479    #[inline(always)]
1480    pub fn set_bit(self) -> &'a mut W {
1481        self.bit(true)
1482    }
1483    #[doc = r"Clears the field bit"]
1484    #[inline(always)]
1485    pub fn clear_bit(self) -> &'a mut W {
1486        self.bit(false)
1487    }
1488    #[doc = r"Writes raw bits to the field"]
1489    #[inline(always)]
1490    pub fn bit(self, value: bool) -> &'a mut W {
1491        self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
1492        self.w
1493    }
1494}
1495#[doc = "Write Protect\n\nValue on reset: 0"]
1496#[derive(Clone, Copy, Debug, PartialEq)]
1497pub enum WP1_A {
1498    #[doc = "0: This peripheral allows write accesses."]
1499    _0,
1500    #[doc = "1: This peripheral is write protected."]
1501    _1,
1502}
1503impl From<WP1_A> for bool {
1504    #[inline(always)]
1505    fn from(variant: WP1_A) -> Self {
1506        match variant {
1507            WP1_A::_0 => false,
1508            WP1_A::_1 => true,
1509        }
1510    }
1511}
1512#[doc = "Reader of field `WP1`"]
1513pub type WP1_R = crate::R<bool, WP1_A>;
1514impl WP1_R {
1515    #[doc = r"Get enumerated values variant"]
1516    #[inline(always)]
1517    pub fn variant(&self) -> WP1_A {
1518        match self.bits {
1519            false => WP1_A::_0,
1520            true => WP1_A::_1,
1521        }
1522    }
1523    #[doc = "Checks if the value of the field is `_0`"]
1524    #[inline(always)]
1525    pub fn is_0(&self) -> bool {
1526        *self == WP1_A::_0
1527    }
1528    #[doc = "Checks if the value of the field is `_1`"]
1529    #[inline(always)]
1530    pub fn is_1(&self) -> bool {
1531        *self == WP1_A::_1
1532    }
1533}
1534#[doc = "Write proxy for field `WP1`"]
1535pub struct WP1_W<'a> {
1536    w: &'a mut W,
1537}
1538impl<'a> WP1_W<'a> {
1539    #[doc = r"Writes `variant` to the field"]
1540    #[inline(always)]
1541    pub fn variant(self, variant: WP1_A) -> &'a mut W {
1542        {
1543            self.bit(variant.into())
1544        }
1545    }
1546    #[doc = "This peripheral allows write accesses."]
1547    #[inline(always)]
1548    pub fn _0(self) -> &'a mut W {
1549        self.variant(WP1_A::_0)
1550    }
1551    #[doc = "This peripheral is write protected."]
1552    #[inline(always)]
1553    pub fn _1(self) -> &'a mut W {
1554        self.variant(WP1_A::_1)
1555    }
1556    #[doc = r"Sets the field bit"]
1557    #[inline(always)]
1558    pub fn set_bit(self) -> &'a mut W {
1559        self.bit(true)
1560    }
1561    #[doc = r"Clears the field bit"]
1562    #[inline(always)]
1563    pub fn clear_bit(self) -> &'a mut W {
1564        self.bit(false)
1565    }
1566    #[doc = r"Writes raw bits to the field"]
1567    #[inline(always)]
1568    pub fn bit(self, value: bool) -> &'a mut W {
1569        self.w.bits = (self.w.bits & !(0x01 << 25)) | (((value as u32) & 0x01) << 25);
1570        self.w
1571    }
1572}
1573#[doc = "Supervisor Protect\n\nValue on reset: 0"]
1574#[derive(Clone, Copy, Debug, PartialEq)]
1575pub enum SP1_A {
1576    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
1577    _0,
1578    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
1579    _1,
1580}
1581impl From<SP1_A> for bool {
1582    #[inline(always)]
1583    fn from(variant: SP1_A) -> Self {
1584        match variant {
1585            SP1_A::_0 => false,
1586            SP1_A::_1 => true,
1587        }
1588    }
1589}
1590#[doc = "Reader of field `SP1`"]
1591pub type SP1_R = crate::R<bool, SP1_A>;
1592impl SP1_R {
1593    #[doc = r"Get enumerated values variant"]
1594    #[inline(always)]
1595    pub fn variant(&self) -> SP1_A {
1596        match self.bits {
1597            false => SP1_A::_0,
1598            true => SP1_A::_1,
1599        }
1600    }
1601    #[doc = "Checks if the value of the field is `_0`"]
1602    #[inline(always)]
1603    pub fn is_0(&self) -> bool {
1604        *self == SP1_A::_0
1605    }
1606    #[doc = "Checks if the value of the field is `_1`"]
1607    #[inline(always)]
1608    pub fn is_1(&self) -> bool {
1609        *self == SP1_A::_1
1610    }
1611}
1612#[doc = "Write proxy for field `SP1`"]
1613pub struct SP1_W<'a> {
1614    w: &'a mut W,
1615}
1616impl<'a> SP1_W<'a> {
1617    #[doc = r"Writes `variant` to the field"]
1618    #[inline(always)]
1619    pub fn variant(self, variant: SP1_A) -> &'a mut W {
1620        {
1621            self.bit(variant.into())
1622        }
1623    }
1624    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1625    #[inline(always)]
1626    pub fn _0(self) -> &'a mut W {
1627        self.variant(SP1_A::_0)
1628    }
1629    #[doc = "This peripheral requires supervisor privilege level for accesses."]
1630    #[inline(always)]
1631    pub fn _1(self) -> &'a mut W {
1632        self.variant(SP1_A::_1)
1633    }
1634    #[doc = r"Sets the field bit"]
1635    #[inline(always)]
1636    pub fn set_bit(self) -> &'a mut W {
1637        self.bit(true)
1638    }
1639    #[doc = r"Clears the field bit"]
1640    #[inline(always)]
1641    pub fn clear_bit(self) -> &'a mut W {
1642        self.bit(false)
1643    }
1644    #[doc = r"Writes raw bits to the field"]
1645    #[inline(always)]
1646    pub fn bit(self, value: bool) -> &'a mut W {
1647        self.w.bits = (self.w.bits & !(0x01 << 26)) | (((value as u32) & 0x01) << 26);
1648        self.w
1649    }
1650}
1651#[doc = "Trusted Protect\n\nValue on reset: 0"]
1652#[derive(Clone, Copy, Debug, PartialEq)]
1653pub enum TP0_A {
1654    #[doc = "0: Accesses from an untrusted master are allowed."]
1655    _0,
1656    #[doc = "1: Accesses from an untrusted master are not allowed."]
1657    _1,
1658}
1659impl From<TP0_A> for bool {
1660    #[inline(always)]
1661    fn from(variant: TP0_A) -> Self {
1662        match variant {
1663            TP0_A::_0 => false,
1664            TP0_A::_1 => true,
1665        }
1666    }
1667}
1668#[doc = "Reader of field `TP0`"]
1669pub type TP0_R = crate::R<bool, TP0_A>;
1670impl TP0_R {
1671    #[doc = r"Get enumerated values variant"]
1672    #[inline(always)]
1673    pub fn variant(&self) -> TP0_A {
1674        match self.bits {
1675            false => TP0_A::_0,
1676            true => TP0_A::_1,
1677        }
1678    }
1679    #[doc = "Checks if the value of the field is `_0`"]
1680    #[inline(always)]
1681    pub fn is_0(&self) -> bool {
1682        *self == TP0_A::_0
1683    }
1684    #[doc = "Checks if the value of the field is `_1`"]
1685    #[inline(always)]
1686    pub fn is_1(&self) -> bool {
1687        *self == TP0_A::_1
1688    }
1689}
1690#[doc = "Write proxy for field `TP0`"]
1691pub struct TP0_W<'a> {
1692    w: &'a mut W,
1693}
1694impl<'a> TP0_W<'a> {
1695    #[doc = r"Writes `variant` to the field"]
1696    #[inline(always)]
1697    pub fn variant(self, variant: TP0_A) -> &'a mut W {
1698        {
1699            self.bit(variant.into())
1700        }
1701    }
1702    #[doc = "Accesses from an untrusted master are allowed."]
1703    #[inline(always)]
1704    pub fn _0(self) -> &'a mut W {
1705        self.variant(TP0_A::_0)
1706    }
1707    #[doc = "Accesses from an untrusted master are not allowed."]
1708    #[inline(always)]
1709    pub fn _1(self) -> &'a mut W {
1710        self.variant(TP0_A::_1)
1711    }
1712    #[doc = r"Sets the field bit"]
1713    #[inline(always)]
1714    pub fn set_bit(self) -> &'a mut W {
1715        self.bit(true)
1716    }
1717    #[doc = r"Clears the field bit"]
1718    #[inline(always)]
1719    pub fn clear_bit(self) -> &'a mut W {
1720        self.bit(false)
1721    }
1722    #[doc = r"Writes raw bits to the field"]
1723    #[inline(always)]
1724    pub fn bit(self, value: bool) -> &'a mut W {
1725        self.w.bits = (self.w.bits & !(0x01 << 28)) | (((value as u32) & 0x01) << 28);
1726        self.w
1727    }
1728}
1729#[doc = "Write Protect\n\nValue on reset: 0"]
1730#[derive(Clone, Copy, Debug, PartialEq)]
1731pub enum WP0_A {
1732    #[doc = "0: This peripheral allows write accesses."]
1733    _0,
1734    #[doc = "1: This peripheral is write protected."]
1735    _1,
1736}
1737impl From<WP0_A> for bool {
1738    #[inline(always)]
1739    fn from(variant: WP0_A) -> Self {
1740        match variant {
1741            WP0_A::_0 => false,
1742            WP0_A::_1 => true,
1743        }
1744    }
1745}
1746#[doc = "Reader of field `WP0`"]
1747pub type WP0_R = crate::R<bool, WP0_A>;
1748impl WP0_R {
1749    #[doc = r"Get enumerated values variant"]
1750    #[inline(always)]
1751    pub fn variant(&self) -> WP0_A {
1752        match self.bits {
1753            false => WP0_A::_0,
1754            true => WP0_A::_1,
1755        }
1756    }
1757    #[doc = "Checks if the value of the field is `_0`"]
1758    #[inline(always)]
1759    pub fn is_0(&self) -> bool {
1760        *self == WP0_A::_0
1761    }
1762    #[doc = "Checks if the value of the field is `_1`"]
1763    #[inline(always)]
1764    pub fn is_1(&self) -> bool {
1765        *self == WP0_A::_1
1766    }
1767}
1768#[doc = "Write proxy for field `WP0`"]
1769pub struct WP0_W<'a> {
1770    w: &'a mut W,
1771}
1772impl<'a> WP0_W<'a> {
1773    #[doc = r"Writes `variant` to the field"]
1774    #[inline(always)]
1775    pub fn variant(self, variant: WP0_A) -> &'a mut W {
1776        {
1777            self.bit(variant.into())
1778        }
1779    }
1780    #[doc = "This peripheral allows write accesses."]
1781    #[inline(always)]
1782    pub fn _0(self) -> &'a mut W {
1783        self.variant(WP0_A::_0)
1784    }
1785    #[doc = "This peripheral is write protected."]
1786    #[inline(always)]
1787    pub fn _1(self) -> &'a mut W {
1788        self.variant(WP0_A::_1)
1789    }
1790    #[doc = r"Sets the field bit"]
1791    #[inline(always)]
1792    pub fn set_bit(self) -> &'a mut W {
1793        self.bit(true)
1794    }
1795    #[doc = r"Clears the field bit"]
1796    #[inline(always)]
1797    pub fn clear_bit(self) -> &'a mut W {
1798        self.bit(false)
1799    }
1800    #[doc = r"Writes raw bits to the field"]
1801    #[inline(always)]
1802    pub fn bit(self, value: bool) -> &'a mut W {
1803        self.w.bits = (self.w.bits & !(0x01 << 29)) | (((value as u32) & 0x01) << 29);
1804        self.w
1805    }
1806}
1807#[doc = "Supervisor Protect\n\nValue on reset: 0"]
1808#[derive(Clone, Copy, Debug, PartialEq)]
1809pub enum SP0_A {
1810    #[doc = "0: This peripheral does not require supervisor privilege level for accesses."]
1811    _0,
1812    #[doc = "1: This peripheral requires supervisor privilege level for accesses."]
1813    _1,
1814}
1815impl From<SP0_A> for bool {
1816    #[inline(always)]
1817    fn from(variant: SP0_A) -> Self {
1818        match variant {
1819            SP0_A::_0 => false,
1820            SP0_A::_1 => true,
1821        }
1822    }
1823}
1824#[doc = "Reader of field `SP0`"]
1825pub type SP0_R = crate::R<bool, SP0_A>;
1826impl SP0_R {
1827    #[doc = r"Get enumerated values variant"]
1828    #[inline(always)]
1829    pub fn variant(&self) -> SP0_A {
1830        match self.bits {
1831            false => SP0_A::_0,
1832            true => SP0_A::_1,
1833        }
1834    }
1835    #[doc = "Checks if the value of the field is `_0`"]
1836    #[inline(always)]
1837    pub fn is_0(&self) -> bool {
1838        *self == SP0_A::_0
1839    }
1840    #[doc = "Checks if the value of the field is `_1`"]
1841    #[inline(always)]
1842    pub fn is_1(&self) -> bool {
1843        *self == SP0_A::_1
1844    }
1845}
1846#[doc = "Write proxy for field `SP0`"]
1847pub struct SP0_W<'a> {
1848    w: &'a mut W,
1849}
1850impl<'a> SP0_W<'a> {
1851    #[doc = r"Writes `variant` to the field"]
1852    #[inline(always)]
1853    pub fn variant(self, variant: SP0_A) -> &'a mut W {
1854        {
1855            self.bit(variant.into())
1856        }
1857    }
1858    #[doc = "This peripheral does not require supervisor privilege level for accesses."]
1859    #[inline(always)]
1860    pub fn _0(self) -> &'a mut W {
1861        self.variant(SP0_A::_0)
1862    }
1863    #[doc = "This peripheral requires supervisor privilege level for accesses."]
1864    #[inline(always)]
1865    pub fn _1(self) -> &'a mut W {
1866        self.variant(SP0_A::_1)
1867    }
1868    #[doc = r"Sets the field bit"]
1869    #[inline(always)]
1870    pub fn set_bit(self) -> &'a mut W {
1871        self.bit(true)
1872    }
1873    #[doc = r"Clears the field bit"]
1874    #[inline(always)]
1875    pub fn clear_bit(self) -> &'a mut W {
1876        self.bit(false)
1877    }
1878    #[doc = r"Writes raw bits to the field"]
1879    #[inline(always)]
1880    pub fn bit(self, value: bool) -> &'a mut W {
1881        self.w.bits = (self.w.bits & !(0x01 << 30)) | (((value as u32) & 0x01) << 30);
1882        self.w
1883    }
1884}
1885impl R {
1886    #[doc = "Bit 0 - Trusted Protect"]
1887    #[inline(always)]
1888    pub fn tp7(&self) -> TP7_R {
1889        TP7_R::new((self.bits & 0x01) != 0)
1890    }
1891    #[doc = "Bit 1 - Write Protect"]
1892    #[inline(always)]
1893    pub fn wp7(&self) -> WP7_R {
1894        WP7_R::new(((self.bits >> 1) & 0x01) != 0)
1895    }
1896    #[doc = "Bit 2 - Supervisor Protect"]
1897    #[inline(always)]
1898    pub fn sp7(&self) -> SP7_R {
1899        SP7_R::new(((self.bits >> 2) & 0x01) != 0)
1900    }
1901    #[doc = "Bit 4 - Trusted Protect"]
1902    #[inline(always)]
1903    pub fn tp6(&self) -> TP6_R {
1904        TP6_R::new(((self.bits >> 4) & 0x01) != 0)
1905    }
1906    #[doc = "Bit 5 - Write Protect"]
1907    #[inline(always)]
1908    pub fn wp6(&self) -> WP6_R {
1909        WP6_R::new(((self.bits >> 5) & 0x01) != 0)
1910    }
1911    #[doc = "Bit 6 - Supervisor Protect"]
1912    #[inline(always)]
1913    pub fn sp6(&self) -> SP6_R {
1914        SP6_R::new(((self.bits >> 6) & 0x01) != 0)
1915    }
1916    #[doc = "Bit 8 - Trusted Protect"]
1917    #[inline(always)]
1918    pub fn tp5(&self) -> TP5_R {
1919        TP5_R::new(((self.bits >> 8) & 0x01) != 0)
1920    }
1921    #[doc = "Bit 9 - Write Protect"]
1922    #[inline(always)]
1923    pub fn wp5(&self) -> WP5_R {
1924        WP5_R::new(((self.bits >> 9) & 0x01) != 0)
1925    }
1926    #[doc = "Bit 10 - Supervisor Protect"]
1927    #[inline(always)]
1928    pub fn sp5(&self) -> SP5_R {
1929        SP5_R::new(((self.bits >> 10) & 0x01) != 0)
1930    }
1931    #[doc = "Bit 12 - Trusted Protect"]
1932    #[inline(always)]
1933    pub fn tp4(&self) -> TP4_R {
1934        TP4_R::new(((self.bits >> 12) & 0x01) != 0)
1935    }
1936    #[doc = "Bit 13 - Write Protect"]
1937    #[inline(always)]
1938    pub fn wp4(&self) -> WP4_R {
1939        WP4_R::new(((self.bits >> 13) & 0x01) != 0)
1940    }
1941    #[doc = "Bit 14 - Supervisor Protect"]
1942    #[inline(always)]
1943    pub fn sp4(&self) -> SP4_R {
1944        SP4_R::new(((self.bits >> 14) & 0x01) != 0)
1945    }
1946    #[doc = "Bit 16 - Trusted Protect"]
1947    #[inline(always)]
1948    pub fn tp3(&self) -> TP3_R {
1949        TP3_R::new(((self.bits >> 16) & 0x01) != 0)
1950    }
1951    #[doc = "Bit 17 - Write Protect"]
1952    #[inline(always)]
1953    pub fn wp3(&self) -> WP3_R {
1954        WP3_R::new(((self.bits >> 17) & 0x01) != 0)
1955    }
1956    #[doc = "Bit 18 - Supervisor Protect"]
1957    #[inline(always)]
1958    pub fn sp3(&self) -> SP3_R {
1959        SP3_R::new(((self.bits >> 18) & 0x01) != 0)
1960    }
1961    #[doc = "Bit 20 - Trusted Protect"]
1962    #[inline(always)]
1963    pub fn tp2(&self) -> TP2_R {
1964        TP2_R::new(((self.bits >> 20) & 0x01) != 0)
1965    }
1966    #[doc = "Bit 21 - Write Protect"]
1967    #[inline(always)]
1968    pub fn wp2(&self) -> WP2_R {
1969        WP2_R::new(((self.bits >> 21) & 0x01) != 0)
1970    }
1971    #[doc = "Bit 22 - Supervisor Protect"]
1972    #[inline(always)]
1973    pub fn sp2(&self) -> SP2_R {
1974        SP2_R::new(((self.bits >> 22) & 0x01) != 0)
1975    }
1976    #[doc = "Bit 24 - Trusted Protect"]
1977    #[inline(always)]
1978    pub fn tp1(&self) -> TP1_R {
1979        TP1_R::new(((self.bits >> 24) & 0x01) != 0)
1980    }
1981    #[doc = "Bit 25 - Write Protect"]
1982    #[inline(always)]
1983    pub fn wp1(&self) -> WP1_R {
1984        WP1_R::new(((self.bits >> 25) & 0x01) != 0)
1985    }
1986    #[doc = "Bit 26 - Supervisor Protect"]
1987    #[inline(always)]
1988    pub fn sp1(&self) -> SP1_R {
1989        SP1_R::new(((self.bits >> 26) & 0x01) != 0)
1990    }
1991    #[doc = "Bit 28 - Trusted Protect"]
1992    #[inline(always)]
1993    pub fn tp0(&self) -> TP0_R {
1994        TP0_R::new(((self.bits >> 28) & 0x01) != 0)
1995    }
1996    #[doc = "Bit 29 - Write Protect"]
1997    #[inline(always)]
1998    pub fn wp0(&self) -> WP0_R {
1999        WP0_R::new(((self.bits >> 29) & 0x01) != 0)
2000    }
2001    #[doc = "Bit 30 - Supervisor Protect"]
2002    #[inline(always)]
2003    pub fn sp0(&self) -> SP0_R {
2004        SP0_R::new(((self.bits >> 30) & 0x01) != 0)
2005    }
2006}
2007impl W {
2008    #[doc = "Bit 0 - Trusted Protect"]
2009    #[inline(always)]
2010    pub fn tp7(&mut self) -> TP7_W {
2011        TP7_W { w: self }
2012    }
2013    #[doc = "Bit 1 - Write Protect"]
2014    #[inline(always)]
2015    pub fn wp7(&mut self) -> WP7_W {
2016        WP7_W { w: self }
2017    }
2018    #[doc = "Bit 2 - Supervisor Protect"]
2019    #[inline(always)]
2020    pub fn sp7(&mut self) -> SP7_W {
2021        SP7_W { w: self }
2022    }
2023    #[doc = "Bit 4 - Trusted Protect"]
2024    #[inline(always)]
2025    pub fn tp6(&mut self) -> TP6_W {
2026        TP6_W { w: self }
2027    }
2028    #[doc = "Bit 5 - Write Protect"]
2029    #[inline(always)]
2030    pub fn wp6(&mut self) -> WP6_W {
2031        WP6_W { w: self }
2032    }
2033    #[doc = "Bit 6 - Supervisor Protect"]
2034    #[inline(always)]
2035    pub fn sp6(&mut self) -> SP6_W {
2036        SP6_W { w: self }
2037    }
2038    #[doc = "Bit 8 - Trusted Protect"]
2039    #[inline(always)]
2040    pub fn tp5(&mut self) -> TP5_W {
2041        TP5_W { w: self }
2042    }
2043    #[doc = "Bit 9 - Write Protect"]
2044    #[inline(always)]
2045    pub fn wp5(&mut self) -> WP5_W {
2046        WP5_W { w: self }
2047    }
2048    #[doc = "Bit 10 - Supervisor Protect"]
2049    #[inline(always)]
2050    pub fn sp5(&mut self) -> SP5_W {
2051        SP5_W { w: self }
2052    }
2053    #[doc = "Bit 12 - Trusted Protect"]
2054    #[inline(always)]
2055    pub fn tp4(&mut self) -> TP4_W {
2056        TP4_W { w: self }
2057    }
2058    #[doc = "Bit 13 - Write Protect"]
2059    #[inline(always)]
2060    pub fn wp4(&mut self) -> WP4_W {
2061        WP4_W { w: self }
2062    }
2063    #[doc = "Bit 14 - Supervisor Protect"]
2064    #[inline(always)]
2065    pub fn sp4(&mut self) -> SP4_W {
2066        SP4_W { w: self }
2067    }
2068    #[doc = "Bit 16 - Trusted Protect"]
2069    #[inline(always)]
2070    pub fn tp3(&mut self) -> TP3_W {
2071        TP3_W { w: self }
2072    }
2073    #[doc = "Bit 17 - Write Protect"]
2074    #[inline(always)]
2075    pub fn wp3(&mut self) -> WP3_W {
2076        WP3_W { w: self }
2077    }
2078    #[doc = "Bit 18 - Supervisor Protect"]
2079    #[inline(always)]
2080    pub fn sp3(&mut self) -> SP3_W {
2081        SP3_W { w: self }
2082    }
2083    #[doc = "Bit 20 - Trusted Protect"]
2084    #[inline(always)]
2085    pub fn tp2(&mut self) -> TP2_W {
2086        TP2_W { w: self }
2087    }
2088    #[doc = "Bit 21 - Write Protect"]
2089    #[inline(always)]
2090    pub fn wp2(&mut self) -> WP2_W {
2091        WP2_W { w: self }
2092    }
2093    #[doc = "Bit 22 - Supervisor Protect"]
2094    #[inline(always)]
2095    pub fn sp2(&mut self) -> SP2_W {
2096        SP2_W { w: self }
2097    }
2098    #[doc = "Bit 24 - Trusted Protect"]
2099    #[inline(always)]
2100    pub fn tp1(&mut self) -> TP1_W {
2101        TP1_W { w: self }
2102    }
2103    #[doc = "Bit 25 - Write Protect"]
2104    #[inline(always)]
2105    pub fn wp1(&mut self) -> WP1_W {
2106        WP1_W { w: self }
2107    }
2108    #[doc = "Bit 26 - Supervisor Protect"]
2109    #[inline(always)]
2110    pub fn sp1(&mut self) -> SP1_W {
2111        SP1_W { w: self }
2112    }
2113    #[doc = "Bit 28 - Trusted Protect"]
2114    #[inline(always)]
2115    pub fn tp0(&mut self) -> TP0_W {
2116        TP0_W { w: self }
2117    }
2118    #[doc = "Bit 29 - Write Protect"]
2119    #[inline(always)]
2120    pub fn wp0(&mut self) -> WP0_W {
2121        WP0_W { w: self }
2122    }
2123    #[doc = "Bit 30 - Supervisor Protect"]
2124    #[inline(always)]
2125    pub fn sp0(&mut self) -> SP0_W {
2126        SP0_W { w: self }
2127    }
2128}
mk66f18/aips0/pacrn.rs

mk66f18/aips0/
pacrn.rs
