k22f/aips1/
pacri.rs

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

k22f/aips1/
pacri.rs
