ra4e2_pac/
pscu.rs

1/*
2DISCLAIMER
3This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
4No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
5applicable laws, including copyright laws.
6THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
7OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
8NON-INFRINGEMENT.  ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
9LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
10INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
11ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
12Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability
13of this software. By using this software, you agree to the additional terms and conditions found by accessing the
14following link:
15http://www.renesas.com/disclaimer
16
17*/
18// Generated from SVD 1.30.00, with svd2pac 0.6.0 on Thu, 24 Jul 2025 04:48:35 +0000
19
20#![allow(clippy::identity_op)]
21#![allow(clippy::module_inception)]
22#![allow(clippy::derivable_impls)]
23#[allow(unused_imports)]
24use crate::common::sealed;
25#[allow(unused_imports)]
26use crate::common::*;
27#[doc = r"Peripheral Security Control Unit"]
28unsafe impl ::core::marker::Send for super::Pscu {}
29unsafe impl ::core::marker::Sync for super::Pscu {}
30impl super::Pscu {
31    #[allow(unused)]
32    #[inline(always)]
33    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
34        self.ptr
35    }
36
37    #[doc = "Peripheral Security Attribution Register B"]
38    #[inline(always)]
39    pub const fn psarb(&self) -> &'static crate::common::Reg<self::Psarb_SPEC, crate::common::RW> {
40        unsafe {
41            crate::common::Reg::<self::Psarb_SPEC, crate::common::RW>::from_ptr(
42                self._svd2pac_as_ptr().add(4usize),
43            )
44        }
45    }
46
47    #[doc = "Peripheral Security Attribution Register C"]
48    #[inline(always)]
49    pub const fn psarc(&self) -> &'static crate::common::Reg<self::Psarc_SPEC, crate::common::RW> {
50        unsafe {
51            crate::common::Reg::<self::Psarc_SPEC, crate::common::RW>::from_ptr(
52                self._svd2pac_as_ptr().add(8usize),
53            )
54        }
55    }
56
57    #[doc = "Peripheral Security Attribution Register D"]
58    #[inline(always)]
59    pub const fn psard(&self) -> &'static crate::common::Reg<self::Psard_SPEC, crate::common::RW> {
60        unsafe {
61            crate::common::Reg::<self::Psard_SPEC, crate::common::RW>::from_ptr(
62                self._svd2pac_as_ptr().add(12usize),
63            )
64        }
65    }
66
67    #[doc = "Peripheral Security Attribution Register E"]
68    #[inline(always)]
69    pub const fn psare(&self) -> &'static crate::common::Reg<self::Psare_SPEC, crate::common::RW> {
70        unsafe {
71            crate::common::Reg::<self::Psare_SPEC, crate::common::RW>::from_ptr(
72                self._svd2pac_as_ptr().add(16usize),
73            )
74        }
75    }
76
77    #[doc = "Module Stop Security Attribution Register"]
78    #[inline(always)]
79    pub const fn mssar(&self) -> &'static crate::common::Reg<self::Mssar_SPEC, crate::common::RW> {
80        unsafe {
81            crate::common::Reg::<self::Mssar_SPEC, crate::common::RW>::from_ptr(
82                self._svd2pac_as_ptr().add(20usize),
83            )
84        }
85    }
86
87    #[doc = "Code Flash Security Attribution Register A"]
88    #[inline(always)]
89    pub const fn cfsamona(
90        &self,
91    ) -> &'static crate::common::Reg<self::Cfsamona_SPEC, crate::common::RW> {
92        unsafe {
93            crate::common::Reg::<self::Cfsamona_SPEC, crate::common::RW>::from_ptr(
94                self._svd2pac_as_ptr().add(24usize),
95            )
96        }
97    }
98
99    #[doc = "Code Flash Security Attribution Register B"]
100    #[inline(always)]
101    pub const fn cfsamonb(
102        &self,
103    ) -> &'static crate::common::Reg<self::Cfsamonb_SPEC, crate::common::RW> {
104        unsafe {
105            crate::common::Reg::<self::Cfsamonb_SPEC, crate::common::RW>::from_ptr(
106                self._svd2pac_as_ptr().add(28usize),
107            )
108        }
109    }
110
111    #[doc = "Data Flash Security Attribution Register"]
112    #[inline(always)]
113    pub const fn dfsamon(
114        &self,
115    ) -> &'static crate::common::Reg<self::Dfsamon_SPEC, crate::common::RW> {
116        unsafe {
117            crate::common::Reg::<self::Dfsamon_SPEC, crate::common::RW>::from_ptr(
118                self._svd2pac_as_ptr().add(32usize),
119            )
120        }
121    }
122
123    #[doc = "SRAM Security Attribution Register A"]
124    #[inline(always)]
125    pub const fn ssamona(
126        &self,
127    ) -> &'static crate::common::Reg<self::Ssamona_SPEC, crate::common::RW> {
128        unsafe {
129            crate::common::Reg::<self::Ssamona_SPEC, crate::common::RW>::from_ptr(
130                self._svd2pac_as_ptr().add(36usize),
131            )
132        }
133    }
134
135    #[doc = "SRAM Security Attribution Register B"]
136    #[inline(always)]
137    pub const fn ssamonb(
138        &self,
139    ) -> &'static crate::common::Reg<self::Ssamonb_SPEC, crate::common::RW> {
140        unsafe {
141            crate::common::Reg::<self::Ssamonb_SPEC, crate::common::RW>::from_ptr(
142                self._svd2pac_as_ptr().add(40usize),
143            )
144        }
145    }
146}
147#[doc(hidden)]
148#[derive(Copy, Clone, Eq, PartialEq)]
149pub struct Psarb_SPEC;
150impl crate::sealed::RegSpec for Psarb_SPEC {
151    type DataType = u32;
152}
153
154#[doc = "Peripheral Security Attribution Register B"]
155pub type Psarb = crate::RegValueT<Psarb_SPEC>;
156
157impl Psarb {
158    #[doc = "CEC and the MSTPCRB.MSTPB3 bit security attribution"]
159    #[inline(always)]
160    pub fn psarb3(
161        self,
162    ) -> crate::common::RegisterField<
163        3,
164        0x1,
165        1,
166        0,
167        psarb::Psarb3,
168        psarb::Psarb3,
169        Psarb_SPEC,
170        crate::common::RW,
171    > {
172        crate::common::RegisterField::<
173            3,
174            0x1,
175            1,
176            0,
177            psarb::Psarb3,
178            psarb::Psarb3,
179            Psarb_SPEC,
180            crate::common::RW,
181        >::from_register(self, 0)
182    }
183
184    #[doc = "I3C and the MSTPCRB.MSTPB4 bit security attribution"]
185    #[inline(always)]
186    pub fn psarb4(
187        self,
188    ) -> crate::common::RegisterField<
189        4,
190        0x1,
191        1,
192        0,
193        psarb::Psarb4,
194        psarb::Psarb4,
195        Psarb_SPEC,
196        crate::common::RW,
197    > {
198        crate::common::RegisterField::<
199            4,
200            0x1,
201            1,
202            0,
203            psarb::Psarb4,
204            psarb::Psarb4,
205            Psarb_SPEC,
206            crate::common::RW,
207        >::from_register(self, 0)
208    }
209
210    #[doc = "USBFS and the MSTPCRB.MSTPB11 bit security attribution"]
211    #[inline(always)]
212    pub fn psarb11(
213        self,
214    ) -> crate::common::RegisterField<
215        11,
216        0x1,
217        1,
218        0,
219        psarb::Psarb11,
220        psarb::Psarb11,
221        Psarb_SPEC,
222        crate::common::RW,
223    > {
224        crate::common::RegisterField::<
225            11,
226            0x1,
227            1,
228            0,
229            psarb::Psarb11,
230            psarb::Psarb11,
231            Psarb_SPEC,
232            crate::common::RW,
233        >::from_register(self, 0)
234    }
235
236    #[doc = "SPI1 and the MSTPCRB.MSTPB18 bit security attribution"]
237    #[inline(always)]
238    pub fn psarb18(
239        self,
240    ) -> crate::common::RegisterField<
241        18,
242        0x1,
243        1,
244        0,
245        psarb::Psarb18,
246        psarb::Psarb18,
247        Psarb_SPEC,
248        crate::common::RW,
249    > {
250        crate::common::RegisterField::<
251            18,
252            0x1,
253            1,
254            0,
255            psarb::Psarb18,
256            psarb::Psarb18,
257            Psarb_SPEC,
258            crate::common::RW,
259        >::from_register(self, 0)
260    }
261
262    #[doc = "SPI0 and the MSTPCRB.MSTPB19 bit security attribution"]
263    #[inline(always)]
264    pub fn psarb19(
265        self,
266    ) -> crate::common::RegisterField<
267        19,
268        0x1,
269        1,
270        0,
271        psarb::Psarb19,
272        psarb::Psarb19,
273        Psarb_SPEC,
274        crate::common::RW,
275    > {
276        crate::common::RegisterField::<
277            19,
278            0x1,
279            1,
280            0,
281            psarb::Psarb19,
282            psarb::Psarb19,
283            Psarb_SPEC,
284            crate::common::RW,
285        >::from_register(self, 0)
286    }
287
288    #[doc = "SCI9 and the MSTPCRB.MSTPB22 bit security attribution"]
289    #[inline(always)]
290    pub fn psarb22(
291        self,
292    ) -> crate::common::RegisterField<
293        22,
294        0x1,
295        1,
296        0,
297        psarb::Psarb22,
298        psarb::Psarb22,
299        Psarb_SPEC,
300        crate::common::RW,
301    > {
302        crate::common::RegisterField::<
303            22,
304            0x1,
305            1,
306            0,
307            psarb::Psarb22,
308            psarb::Psarb22,
309            Psarb_SPEC,
310            crate::common::RW,
311        >::from_register(self, 0)
312    }
313
314    #[doc = "SCI0 and the MSTPCRB.MSTPB31 bit security attribution"]
315    #[inline(always)]
316    pub fn psarb31(
317        self,
318    ) -> crate::common::RegisterField<
319        31,
320        0x1,
321        1,
322        0,
323        psarb::Psarb31,
324        psarb::Psarb31,
325        Psarb_SPEC,
326        crate::common::RW,
327    > {
328        crate::common::RegisterField::<
329            31,
330            0x1,
331            1,
332            0,
333            psarb::Psarb31,
334            psarb::Psarb31,
335            Psarb_SPEC,
336            crate::common::RW,
337        >::from_register(self, 0)
338    }
339}
340impl ::core::default::Default for Psarb {
341    #[inline(always)]
342    fn default() -> Psarb {
343        <crate::RegValueT<Psarb_SPEC> as RegisterValue<_>>::new(4294967295)
344    }
345}
346pub mod psarb {
347
348    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
349    pub struct Psarb3_SPEC;
350    pub type Psarb3 = crate::EnumBitfieldStruct<u8, Psarb3_SPEC>;
351    impl Psarb3 {
352        #[doc = "Secure"]
353        pub const _0: Self = Self::new(0);
354
355        #[doc = "Non-secure"]
356        pub const _1: Self = Self::new(1);
357    }
358    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
359    pub struct Psarb4_SPEC;
360    pub type Psarb4 = crate::EnumBitfieldStruct<u8, Psarb4_SPEC>;
361    impl Psarb4 {
362        #[doc = "Secure"]
363        pub const _0: Self = Self::new(0);
364
365        #[doc = "Non-secure"]
366        pub const _1: Self = Self::new(1);
367    }
368    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
369    pub struct Psarb11_SPEC;
370    pub type Psarb11 = crate::EnumBitfieldStruct<u8, Psarb11_SPEC>;
371    impl Psarb11 {
372        #[doc = "Secure"]
373        pub const _0: Self = Self::new(0);
374
375        #[doc = "Non-secure"]
376        pub const _1: Self = Self::new(1);
377    }
378    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
379    pub struct Psarb18_SPEC;
380    pub type Psarb18 = crate::EnumBitfieldStruct<u8, Psarb18_SPEC>;
381    impl Psarb18 {
382        #[doc = "Secure"]
383        pub const _0: Self = Self::new(0);
384
385        #[doc = "Non-secure"]
386        pub const _1: Self = Self::new(1);
387    }
388    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
389    pub struct Psarb19_SPEC;
390    pub type Psarb19 = crate::EnumBitfieldStruct<u8, Psarb19_SPEC>;
391    impl Psarb19 {
392        #[doc = "Secure"]
393        pub const _0: Self = Self::new(0);
394
395        #[doc = "Non-secure"]
396        pub const _1: Self = Self::new(1);
397    }
398    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
399    pub struct Psarb22_SPEC;
400    pub type Psarb22 = crate::EnumBitfieldStruct<u8, Psarb22_SPEC>;
401    impl Psarb22 {
402        #[doc = "Secure"]
403        pub const _0: Self = Self::new(0);
404
405        #[doc = "Non-secure"]
406        pub const _1: Self = Self::new(1);
407    }
408    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
409    pub struct Psarb31_SPEC;
410    pub type Psarb31 = crate::EnumBitfieldStruct<u8, Psarb31_SPEC>;
411    impl Psarb31 {
412        #[doc = "Secure"]
413        pub const _0: Self = Self::new(0);
414
415        #[doc = "Non-secure"]
416        pub const _1: Self = Self::new(1);
417    }
418}
419#[doc(hidden)]
420#[derive(Copy, Clone, Eq, PartialEq)]
421pub struct Psarc_SPEC;
422impl crate::sealed::RegSpec for Psarc_SPEC {
423    type DataType = u32;
424}
425
426#[doc = "Peripheral Security Attribution Register C"]
427pub type Psarc = crate::RegValueT<Psarc_SPEC>;
428
429impl Psarc {
430    #[doc = "CAC and the MSTPCRC.MSTPC0 bit security attribution"]
431    #[inline(always)]
432    pub fn psarc0(
433        self,
434    ) -> crate::common::RegisterField<
435        0,
436        0x1,
437        1,
438        0,
439        psarc::Psarc0,
440        psarc::Psarc0,
441        Psarc_SPEC,
442        crate::common::RW,
443    > {
444        crate::common::RegisterField::<
445            0,
446            0x1,
447            1,
448            0,
449            psarc::Psarc0,
450            psarc::Psarc0,
451            Psarc_SPEC,
452            crate::common::RW,
453        >::from_register(self, 0)
454    }
455
456    #[doc = "CRC and the MSTPCRC.MSTPC1 bit security attribution"]
457    #[inline(always)]
458    pub fn psarc1(
459        self,
460    ) -> crate::common::RegisterField<
461        1,
462        0x1,
463        1,
464        0,
465        psarc::Psarc1,
466        psarc::Psarc1,
467        Psarc_SPEC,
468        crate::common::RW,
469    > {
470        crate::common::RegisterField::<
471            1,
472            0x1,
473            1,
474            0,
475            psarc::Psarc1,
476            psarc::Psarc1,
477            Psarc_SPEC,
478            crate::common::RW,
479        >::from_register(self, 0)
480    }
481
482    #[doc = "SSIE0 and the MSTPCRC.MSTPC8 bit security attribution"]
483    #[inline(always)]
484    pub fn psarc8(
485        self,
486    ) -> crate::common::RegisterField<
487        8,
488        0x1,
489        1,
490        0,
491        psarc::Psarc8,
492        psarc::Psarc8,
493        Psarc_SPEC,
494        crate::common::RW,
495    > {
496        crate::common::RegisterField::<
497            8,
498            0x1,
499            1,
500            0,
501            psarc::Psarc8,
502            psarc::Psarc8,
503            Psarc_SPEC,
504            crate::common::RW,
505        >::from_register(self, 0)
506    }
507
508    #[doc = "DOC and the MSTPCRC.MSTPC13 bit security attribution"]
509    #[inline(always)]
510    pub fn psarc13(
511        self,
512    ) -> crate::common::RegisterField<
513        13,
514        0x1,
515        1,
516        0,
517        psarc::Psarc13,
518        psarc::Psarc13,
519        Psarc_SPEC,
520        crate::common::RW,
521    > {
522        crate::common::RegisterField::<
523            13,
524            0x1,
525            1,
526            0,
527            psarc::Psarc13,
528            psarc::Psarc13,
529            Psarc_SPEC,
530            crate::common::RW,
531        >::from_register(self, 0)
532    }
533
534    #[doc = "CANFD0 and the MSTPCRC.MSTPC27 bit security attribution"]
535    #[inline(always)]
536    pub fn psarc27(
537        self,
538    ) -> crate::common::RegisterField<
539        27,
540        0x1,
541        1,
542        0,
543        psarc::Psarc27,
544        psarc::Psarc27,
545        Psarc_SPEC,
546        crate::common::RW,
547    > {
548        crate::common::RegisterField::<
549            27,
550            0x1,
551            1,
552            0,
553            psarc::Psarc27,
554            psarc::Psarc27,
555            Psarc_SPEC,
556            crate::common::RW,
557        >::from_register(self, 0)
558    }
559
560    #[doc = "TRNG and the MSTPCRC.MSTPC28 bit security attribution"]
561    #[inline(always)]
562    pub fn psarc28(
563        self,
564    ) -> crate::common::RegisterField<
565        28,
566        0x1,
567        1,
568        0,
569        psarc::Psarc28,
570        psarc::Psarc28,
571        Psarc_SPEC,
572        crate::common::RW,
573    > {
574        crate::common::RegisterField::<
575            28,
576            0x1,
577            1,
578            0,
579            psarc::Psarc28,
580            psarc::Psarc28,
581            Psarc_SPEC,
582            crate::common::RW,
583        >::from_register(self, 0)
584    }
585}
586impl ::core::default::Default for Psarc {
587    #[inline(always)]
588    fn default() -> Psarc {
589        <crate::RegValueT<Psarc_SPEC> as RegisterValue<_>>::new(4294967295)
590    }
591}
592pub mod psarc {
593
594    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
595    pub struct Psarc0_SPEC;
596    pub type Psarc0 = crate::EnumBitfieldStruct<u8, Psarc0_SPEC>;
597    impl Psarc0 {
598        #[doc = "Secure"]
599        pub const _0: Self = Self::new(0);
600
601        #[doc = "Non-secure"]
602        pub const _1: Self = Self::new(1);
603    }
604    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
605    pub struct Psarc1_SPEC;
606    pub type Psarc1 = crate::EnumBitfieldStruct<u8, Psarc1_SPEC>;
607    impl Psarc1 {
608        #[doc = "Secure"]
609        pub const _0: Self = Self::new(0);
610
611        #[doc = "Non-secure"]
612        pub const _1: Self = Self::new(1);
613    }
614    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
615    pub struct Psarc8_SPEC;
616    pub type Psarc8 = crate::EnumBitfieldStruct<u8, Psarc8_SPEC>;
617    impl Psarc8 {
618        #[doc = "Secure"]
619        pub const _0: Self = Self::new(0);
620
621        #[doc = "Non-secure"]
622        pub const _1: Self = Self::new(1);
623    }
624    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
625    pub struct Psarc13_SPEC;
626    pub type Psarc13 = crate::EnumBitfieldStruct<u8, Psarc13_SPEC>;
627    impl Psarc13 {
628        #[doc = "Secure"]
629        pub const _0: Self = Self::new(0);
630
631        #[doc = "Non-secure"]
632        pub const _1: Self = Self::new(1);
633    }
634    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
635    pub struct Psarc27_SPEC;
636    pub type Psarc27 = crate::EnumBitfieldStruct<u8, Psarc27_SPEC>;
637    impl Psarc27 {
638        #[doc = "Secure"]
639        pub const _0: Self = Self::new(0);
640
641        #[doc = "Non-secure"]
642        pub const _1: Self = Self::new(1);
643    }
644    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
645    pub struct Psarc28_SPEC;
646    pub type Psarc28 = crate::EnumBitfieldStruct<u8, Psarc28_SPEC>;
647    impl Psarc28 {
648        #[doc = "Secure"]
649        pub const _0: Self = Self::new(0);
650
651        #[doc = "Non-secure"]
652        pub const _1: Self = Self::new(1);
653    }
654}
655#[doc(hidden)]
656#[derive(Copy, Clone, Eq, PartialEq)]
657pub struct Psard_SPEC;
658impl crate::sealed::RegSpec for Psard_SPEC {
659    type DataType = u32;
660}
661
662#[doc = "Peripheral Security Attribution Register D"]
663pub type Psard = crate::RegValueT<Psard_SPEC>;
664
665impl Psard {
666    #[doc = "AGT1 and the MSTPCRD.MSTPD2 bit security attribution"]
667    #[inline(always)]
668    pub fn psard2(
669        self,
670    ) -> crate::common::RegisterField<
671        2,
672        0x1,
673        1,
674        0,
675        psard::Psard2,
676        psard::Psard2,
677        Psard_SPEC,
678        crate::common::RW,
679    > {
680        crate::common::RegisterField::<
681            2,
682            0x1,
683            1,
684            0,
685            psard::Psard2,
686            psard::Psard2,
687            Psard_SPEC,
688            crate::common::RW,
689        >::from_register(self, 0)
690    }
691
692    #[doc = "AGT0 and the MSTPCRD.MSTPD3 bit security attribution"]
693    #[inline(always)]
694    pub fn psard3(
695        self,
696    ) -> crate::common::RegisterField<
697        3,
698        0x1,
699        1,
700        0,
701        psard::Psard3,
702        psard::Psard3,
703        Psard_SPEC,
704        crate::common::RW,
705    > {
706        crate::common::RegisterField::<
707            3,
708            0x1,
709            1,
710            0,
711            psard::Psard3,
712            psard::Psard3,
713            Psard_SPEC,
714            crate::common::RW,
715        >::from_register(self, 0)
716    }
717
718    #[doc = "POEG Group D and the MSTPCRD.MSTPD11 bit security attribution"]
719    #[inline(always)]
720    pub fn psard11(
721        self,
722    ) -> crate::common::RegisterField<
723        11,
724        0x1,
725        1,
726        0,
727        psard::Psard11,
728        psard::Psard11,
729        Psard_SPEC,
730        crate::common::RW,
731    > {
732        crate::common::RegisterField::<
733            11,
734            0x1,
735            1,
736            0,
737            psard::Psard11,
738            psard::Psard11,
739            Psard_SPEC,
740            crate::common::RW,
741        >::from_register(self, 0)
742    }
743
744    #[doc = "POEG Group C and the MSTPCRD.MSTPD12 bit security attribution"]
745    #[inline(always)]
746    pub fn psard12(
747        self,
748    ) -> crate::common::RegisterField<
749        12,
750        0x1,
751        1,
752        0,
753        psard::Psard12,
754        psard::Psard12,
755        Psard_SPEC,
756        crate::common::RW,
757    > {
758        crate::common::RegisterField::<
759            12,
760            0x1,
761            1,
762            0,
763            psard::Psard12,
764            psard::Psard12,
765            Psard_SPEC,
766            crate::common::RW,
767        >::from_register(self, 0)
768    }
769
770    #[doc = "POEG Group B and the MSTPCRD.MSTPD13 bit security attribution"]
771    #[inline(always)]
772    pub fn psard13(
773        self,
774    ) -> crate::common::RegisterField<
775        13,
776        0x1,
777        1,
778        0,
779        psard::Psard13,
780        psard::Psard13,
781        Psard_SPEC,
782        crate::common::RW,
783    > {
784        crate::common::RegisterField::<
785            13,
786            0x1,
787            1,
788            0,
789            psard::Psard13,
790            psard::Psard13,
791            Psard_SPEC,
792            crate::common::RW,
793        >::from_register(self, 0)
794    }
795
796    #[doc = "POEG Group A and the MSTPCRD.MSTPD14 bit security attribution"]
797    #[inline(always)]
798    pub fn psard14(
799        self,
800    ) -> crate::common::RegisterField<
801        14,
802        0x1,
803        1,
804        0,
805        psard::Psard14,
806        psard::Psard14,
807        Psard_SPEC,
808        crate::common::RW,
809    > {
810        crate::common::RegisterField::<
811            14,
812            0x1,
813            1,
814            0,
815            psard::Psard14,
816            psard::Psard14,
817            Psard_SPEC,
818            crate::common::RW,
819        >::from_register(self, 0)
820    }
821
822    #[doc = "ADC120 and the MSTPCRD.MSTPD16 bit security attribution"]
823    #[inline(always)]
824    pub fn psard16(
825        self,
826    ) -> crate::common::RegisterField<
827        16,
828        0x1,
829        1,
830        0,
831        psard::Psard16,
832        psard::Psard16,
833        Psard_SPEC,
834        crate::common::RW,
835    > {
836        crate::common::RegisterField::<
837            16,
838            0x1,
839            1,
840            0,
841            psard::Psard16,
842            psard::Psard16,
843            Psard_SPEC,
844            crate::common::RW,
845        >::from_register(self, 0)
846    }
847
848    #[doc = "DAC12 and the MSTPCRD.MSTPD20 bit security attribution"]
849    #[inline(always)]
850    pub fn psard20(
851        self,
852    ) -> crate::common::RegisterField<
853        20,
854        0x1,
855        1,
856        0,
857        psard::Psard20,
858        psard::Psard20,
859        Psard_SPEC,
860        crate::common::RW,
861    > {
862        crate::common::RegisterField::<
863            20,
864            0x1,
865            1,
866            0,
867            psard::Psard20,
868            psard::Psard20,
869            Psard_SPEC,
870            crate::common::RW,
871        >::from_register(self, 0)
872    }
873
874    #[doc = "TSN and the MSTPCRD.MSTPD22 bit security attribution"]
875    #[inline(always)]
876    pub fn psard22(
877        self,
878    ) -> crate::common::RegisterField<
879        22,
880        0x1,
881        1,
882        0,
883        psard::Psard22,
884        psard::Psard22,
885        Psard_SPEC,
886        crate::common::RW,
887    > {
888        crate::common::RegisterField::<
889            22,
890            0x1,
891            1,
892            0,
893            psard::Psard22,
894            psard::Psard22,
895            Psard_SPEC,
896            crate::common::RW,
897        >::from_register(self, 0)
898    }
899}
900impl ::core::default::Default for Psard {
901    #[inline(always)]
902    fn default() -> Psard {
903        <crate::RegValueT<Psard_SPEC> as RegisterValue<_>>::new(4294967295)
904    }
905}
906pub mod psard {
907
908    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
909    pub struct Psard2_SPEC;
910    pub type Psard2 = crate::EnumBitfieldStruct<u8, Psard2_SPEC>;
911    impl Psard2 {
912        #[doc = "Secure"]
913        pub const _0: Self = Self::new(0);
914
915        #[doc = "Non-secure"]
916        pub const _1: Self = Self::new(1);
917    }
918    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
919    pub struct Psard3_SPEC;
920    pub type Psard3 = crate::EnumBitfieldStruct<u8, Psard3_SPEC>;
921    impl Psard3 {
922        #[doc = "Secure"]
923        pub const _0: Self = Self::new(0);
924
925        #[doc = "Non-secure"]
926        pub const _1: Self = Self::new(1);
927    }
928    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
929    pub struct Psard11_SPEC;
930    pub type Psard11 = crate::EnumBitfieldStruct<u8, Psard11_SPEC>;
931    impl Psard11 {
932        #[doc = "Secure"]
933        pub const _0: Self = Self::new(0);
934
935        #[doc = "Non-secure"]
936        pub const _1: Self = Self::new(1);
937    }
938    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
939    pub struct Psard12_SPEC;
940    pub type Psard12 = crate::EnumBitfieldStruct<u8, Psard12_SPEC>;
941    impl Psard12 {
942        #[doc = "Secure"]
943        pub const _0: Self = Self::new(0);
944
945        #[doc = "Non-secure"]
946        pub const _1: Self = Self::new(1);
947    }
948    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
949    pub struct Psard13_SPEC;
950    pub type Psard13 = crate::EnumBitfieldStruct<u8, Psard13_SPEC>;
951    impl Psard13 {
952        #[doc = "Secure"]
953        pub const _0: Self = Self::new(0);
954
955        #[doc = "Non-secure"]
956        pub const _1: Self = Self::new(1);
957    }
958    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
959    pub struct Psard14_SPEC;
960    pub type Psard14 = crate::EnumBitfieldStruct<u8, Psard14_SPEC>;
961    impl Psard14 {
962        #[doc = "Secure"]
963        pub const _0: Self = Self::new(0);
964
965        #[doc = "Non-secure"]
966        pub const _1: Self = Self::new(1);
967    }
968    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
969    pub struct Psard16_SPEC;
970    pub type Psard16 = crate::EnumBitfieldStruct<u8, Psard16_SPEC>;
971    impl Psard16 {
972        #[doc = "Secure"]
973        pub const _0: Self = Self::new(0);
974
975        #[doc = "Non-secure"]
976        pub const _1: Self = Self::new(1);
977    }
978    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
979    pub struct Psard20_SPEC;
980    pub type Psard20 = crate::EnumBitfieldStruct<u8, Psard20_SPEC>;
981    impl Psard20 {
982        #[doc = "Secure"]
983        pub const _0: Self = Self::new(0);
984
985        #[doc = "Non-secure"]
986        pub const _1: Self = Self::new(1);
987    }
988    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
989    pub struct Psard22_SPEC;
990    pub type Psard22 = crate::EnumBitfieldStruct<u8, Psard22_SPEC>;
991    impl Psard22 {
992        #[doc = "Secure"]
993        pub const _0: Self = Self::new(0);
994
995        #[doc = "Non-secure"]
996        pub const _1: Self = Self::new(1);
997    }
998}
999#[doc(hidden)]
1000#[derive(Copy, Clone, Eq, PartialEq)]
1001pub struct Psare_SPEC;
1002impl crate::sealed::RegSpec for Psare_SPEC {
1003    type DataType = u32;
1004}
1005
1006#[doc = "Peripheral Security Attribution Register E"]
1007pub type Psare = crate::RegValueT<Psare_SPEC>;
1008
1009impl Psare {
1010    #[doc = "WDT security attribution"]
1011    #[inline(always)]
1012    pub fn psare0(
1013        self,
1014    ) -> crate::common::RegisterField<
1015        0,
1016        0x1,
1017        1,
1018        0,
1019        psare::Psare0,
1020        psare::Psare0,
1021        Psare_SPEC,
1022        crate::common::RW,
1023    > {
1024        crate::common::RegisterField::<
1025            0,
1026            0x1,
1027            1,
1028            0,
1029            psare::Psare0,
1030            psare::Psare0,
1031            Psare_SPEC,
1032            crate::common::RW,
1033        >::from_register(self, 0)
1034    }
1035
1036    #[doc = "IWDT security attribution"]
1037    #[inline(always)]
1038    pub fn psare1(
1039        self,
1040    ) -> crate::common::RegisterField<
1041        1,
1042        0x1,
1043        1,
1044        0,
1045        psare::Psare1,
1046        psare::Psare1,
1047        Psare_SPEC,
1048        crate::common::RW,
1049    > {
1050        crate::common::RegisterField::<
1051            1,
1052            0x1,
1053            1,
1054            0,
1055            psare::Psare1,
1056            psare::Psare1,
1057            Psare_SPEC,
1058            crate::common::RW,
1059        >::from_register(self, 0)
1060    }
1061
1062    #[doc = "RTC security attribution"]
1063    #[inline(always)]
1064    pub fn psare2(
1065        self,
1066    ) -> crate::common::RegisterField<
1067        2,
1068        0x1,
1069        1,
1070        0,
1071        psare::Psare2,
1072        psare::Psare2,
1073        Psare_SPEC,
1074        crate::common::RW,
1075    > {
1076        crate::common::RegisterField::<
1077            2,
1078            0x1,
1079            1,
1080            0,
1081            psare::Psare2,
1082            psare::Psare2,
1083            Psare_SPEC,
1084            crate::common::RW,
1085        >::from_register(self, 0)
1086    }
1087
1088    #[doc = "GPT5 and the MSTPCRE.MSTPE26 bit security attribution"]
1089    #[inline(always)]
1090    pub fn psare26(
1091        self,
1092    ) -> crate::common::RegisterField<
1093        26,
1094        0x1,
1095        1,
1096        0,
1097        psare::Psare26,
1098        psare::Psare26,
1099        Psare_SPEC,
1100        crate::common::RW,
1101    > {
1102        crate::common::RegisterField::<
1103            26,
1104            0x1,
1105            1,
1106            0,
1107            psare::Psare26,
1108            psare::Psare26,
1109            Psare_SPEC,
1110            crate::common::RW,
1111        >::from_register(self, 0)
1112    }
1113
1114    #[doc = "GPT4 and the MSTPCRE.MSTPE27 bit security attribution"]
1115    #[inline(always)]
1116    pub fn psare27(
1117        self,
1118    ) -> crate::common::RegisterField<
1119        27,
1120        0x1,
1121        1,
1122        0,
1123        psare::Psare27,
1124        psare::Psare27,
1125        Psare_SPEC,
1126        crate::common::RW,
1127    > {
1128        crate::common::RegisterField::<
1129            27,
1130            0x1,
1131            1,
1132            0,
1133            psare::Psare27,
1134            psare::Psare27,
1135            Psare_SPEC,
1136            crate::common::RW,
1137        >::from_register(self, 0)
1138    }
1139
1140    #[doc = "GPT1 and the MSTPCRE.MSTPE30 bit security attribution"]
1141    #[inline(always)]
1142    pub fn psare30(
1143        self,
1144    ) -> crate::common::RegisterField<
1145        30,
1146        0x1,
1147        1,
1148        0,
1149        psare::Psare30,
1150        psare::Psare30,
1151        Psare_SPEC,
1152        crate::common::RW,
1153    > {
1154        crate::common::RegisterField::<
1155            30,
1156            0x1,
1157            1,
1158            0,
1159            psare::Psare30,
1160            psare::Psare30,
1161            Psare_SPEC,
1162            crate::common::RW,
1163        >::from_register(self, 0)
1164    }
1165
1166    #[doc = "GPT0, GPT_OPS and the MSTPCRE.MSTPE31 bit security attribution"]
1167    #[inline(always)]
1168    pub fn psare31(
1169        self,
1170    ) -> crate::common::RegisterField<
1171        31,
1172        0x1,
1173        1,
1174        0,
1175        psare::Psare31,
1176        psare::Psare31,
1177        Psare_SPEC,
1178        crate::common::RW,
1179    > {
1180        crate::common::RegisterField::<
1181            31,
1182            0x1,
1183            1,
1184            0,
1185            psare::Psare31,
1186            psare::Psare31,
1187            Psare_SPEC,
1188            crate::common::RW,
1189        >::from_register(self, 0)
1190    }
1191}
1192impl ::core::default::Default for Psare {
1193    #[inline(always)]
1194    fn default() -> Psare {
1195        <crate::RegValueT<Psare_SPEC> as RegisterValue<_>>::new(4294967295)
1196    }
1197}
1198pub mod psare {
1199
1200    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1201    pub struct Psare0_SPEC;
1202    pub type Psare0 = crate::EnumBitfieldStruct<u8, Psare0_SPEC>;
1203    impl Psare0 {
1204        #[doc = "Secure"]
1205        pub const _0: Self = Self::new(0);
1206
1207        #[doc = "Non-secure"]
1208        pub const _1: Self = Self::new(1);
1209    }
1210    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1211    pub struct Psare1_SPEC;
1212    pub type Psare1 = crate::EnumBitfieldStruct<u8, Psare1_SPEC>;
1213    impl Psare1 {
1214        #[doc = "Secure"]
1215        pub const _0: Self = Self::new(0);
1216
1217        #[doc = "Non-secure"]
1218        pub const _1: Self = Self::new(1);
1219    }
1220    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1221    pub struct Psare2_SPEC;
1222    pub type Psare2 = crate::EnumBitfieldStruct<u8, Psare2_SPEC>;
1223    impl Psare2 {
1224        #[doc = "Secure"]
1225        pub const _0: Self = Self::new(0);
1226
1227        #[doc = "Non-secure"]
1228        pub const _1: Self = Self::new(1);
1229    }
1230    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1231    pub struct Psare26_SPEC;
1232    pub type Psare26 = crate::EnumBitfieldStruct<u8, Psare26_SPEC>;
1233    impl Psare26 {
1234        #[doc = "Secure"]
1235        pub const _0: Self = Self::new(0);
1236
1237        #[doc = "Non-secure"]
1238        pub const _1: Self = Self::new(1);
1239    }
1240    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1241    pub struct Psare27_SPEC;
1242    pub type Psare27 = crate::EnumBitfieldStruct<u8, Psare27_SPEC>;
1243    impl Psare27 {
1244        #[doc = "Secure"]
1245        pub const _0: Self = Self::new(0);
1246
1247        #[doc = "Non-secure"]
1248        pub const _1: Self = Self::new(1);
1249    }
1250    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1251    pub struct Psare30_SPEC;
1252    pub type Psare30 = crate::EnumBitfieldStruct<u8, Psare30_SPEC>;
1253    impl Psare30 {
1254        #[doc = "Secure"]
1255        pub const _0: Self = Self::new(0);
1256
1257        #[doc = "Non-secure"]
1258        pub const _1: Self = Self::new(1);
1259    }
1260    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1261    pub struct Psare31_SPEC;
1262    pub type Psare31 = crate::EnumBitfieldStruct<u8, Psare31_SPEC>;
1263    impl Psare31 {
1264        #[doc = "Secure"]
1265        pub const _0: Self = Self::new(0);
1266
1267        #[doc = "Non-secure"]
1268        pub const _1: Self = Self::new(1);
1269    }
1270}
1271#[doc(hidden)]
1272#[derive(Copy, Clone, Eq, PartialEq)]
1273pub struct Mssar_SPEC;
1274impl crate::sealed::RegSpec for Mssar_SPEC {
1275    type DataType = u32;
1276}
1277
1278#[doc = "Module Stop Security Attribution Register"]
1279pub type Mssar = crate::RegValueT<Mssar_SPEC>;
1280
1281impl Mssar {
1282    #[doc = "The MSTPCRC.MSTPC14 bit security attribution"]
1283    #[inline(always)]
1284    pub fn mssar0(
1285        self,
1286    ) -> crate::common::RegisterField<
1287        0,
1288        0x1,
1289        1,
1290        0,
1291        mssar::Mssar0,
1292        mssar::Mssar0,
1293        Mssar_SPEC,
1294        crate::common::RW,
1295    > {
1296        crate::common::RegisterField::<
1297            0,
1298            0x1,
1299            1,
1300            0,
1301            mssar::Mssar0,
1302            mssar::Mssar0,
1303            Mssar_SPEC,
1304            crate::common::RW,
1305        >::from_register(self, 0)
1306    }
1307
1308    #[doc = "The MSTPCRA.MSTPA22 bit security attribution"]
1309    #[inline(always)]
1310    pub fn mssar1(
1311        self,
1312    ) -> crate::common::RegisterField<
1313        1,
1314        0x1,
1315        1,
1316        0,
1317        mssar::Mssar1,
1318        mssar::Mssar1,
1319        Mssar_SPEC,
1320        crate::common::RW,
1321    > {
1322        crate::common::RegisterField::<
1323            1,
1324            0x1,
1325            1,
1326            0,
1327            mssar::Mssar1,
1328            mssar::Mssar1,
1329            Mssar_SPEC,
1330            crate::common::RW,
1331        >::from_register(self, 0)
1332    }
1333
1334    #[doc = "The MSTPCRA.MSTPA7 bit security attribution"]
1335    #[inline(always)]
1336    pub fn mssar2(
1337        self,
1338    ) -> crate::common::RegisterField<
1339        2,
1340        0x1,
1341        1,
1342        0,
1343        mssar::Mssar2,
1344        mssar::Mssar2,
1345        Mssar_SPEC,
1346        crate::common::RW,
1347    > {
1348        crate::common::RegisterField::<
1349            2,
1350            0x1,
1351            1,
1352            0,
1353            mssar::Mssar2,
1354            mssar::Mssar2,
1355            Mssar_SPEC,
1356            crate::common::RW,
1357        >::from_register(self, 0)
1358    }
1359
1360    #[doc = "The MSTPCRA.MSTPA0 bit security attribution"]
1361    #[inline(always)]
1362    pub fn mssar3(
1363        self,
1364    ) -> crate::common::RegisterField<
1365        3,
1366        0x1,
1367        1,
1368        0,
1369        mssar::Mssar3,
1370        mssar::Mssar3,
1371        Mssar_SPEC,
1372        crate::common::RW,
1373    > {
1374        crate::common::RegisterField::<
1375            3,
1376            0x1,
1377            1,
1378            0,
1379            mssar::Mssar3,
1380            mssar::Mssar3,
1381            Mssar_SPEC,
1382            crate::common::RW,
1383        >::from_register(self, 0)
1384    }
1385}
1386impl ::core::default::Default for Mssar {
1387    #[inline(always)]
1388    fn default() -> Mssar {
1389        <crate::RegValueT<Mssar_SPEC> as RegisterValue<_>>::new(4294967295)
1390    }
1391}
1392pub mod mssar {
1393
1394    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1395    pub struct Mssar0_SPEC;
1396    pub type Mssar0 = crate::EnumBitfieldStruct<u8, Mssar0_SPEC>;
1397    impl Mssar0 {
1398        #[doc = "Secure"]
1399        pub const _0: Self = Self::new(0);
1400
1401        #[doc = "Non-secure"]
1402        pub const _1: Self = Self::new(1);
1403    }
1404    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1405    pub struct Mssar1_SPEC;
1406    pub type Mssar1 = crate::EnumBitfieldStruct<u8, Mssar1_SPEC>;
1407    impl Mssar1 {
1408        #[doc = "Secure"]
1409        pub const _0: Self = Self::new(0);
1410
1411        #[doc = "Non-secure"]
1412        pub const _1: Self = Self::new(1);
1413    }
1414    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1415    pub struct Mssar2_SPEC;
1416    pub type Mssar2 = crate::EnumBitfieldStruct<u8, Mssar2_SPEC>;
1417    impl Mssar2 {
1418        #[doc = "Secure"]
1419        pub const _0: Self = Self::new(0);
1420
1421        #[doc = "Non-secure"]
1422        pub const _1: Self = Self::new(1);
1423    }
1424    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1425    pub struct Mssar3_SPEC;
1426    pub type Mssar3 = crate::EnumBitfieldStruct<u8, Mssar3_SPEC>;
1427    impl Mssar3 {
1428        #[doc = "Secure"]
1429        pub const _0: Self = Self::new(0);
1430
1431        #[doc = "Non-secure"]
1432        pub const _1: Self = Self::new(1);
1433    }
1434}
1435#[doc(hidden)]
1436#[derive(Copy, Clone, Eq, PartialEq)]
1437pub struct Cfsamona_SPEC;
1438impl crate::sealed::RegSpec for Cfsamona_SPEC {
1439    type DataType = u32;
1440}
1441
1442#[doc = "Code Flash Security Attribution Register A"]
1443pub type Cfsamona = crate::RegValueT<Cfsamona_SPEC>;
1444
1445impl Cfsamona {
1446    #[doc = "Code Flash Secure area 2"]
1447    #[inline(always)]
1448    pub fn cfs2(
1449        self,
1450    ) -> crate::common::RegisterField<
1451        15,
1452        0x1ff,
1453        1,
1454        0,
1455        cfsamona::Cfs2,
1456        cfsamona::Cfs2,
1457        Cfsamona_SPEC,
1458        crate::common::RW,
1459    > {
1460        crate::common::RegisterField::<
1461            15,
1462            0x1ff,
1463            1,
1464            0,
1465            cfsamona::Cfs2,
1466            cfsamona::Cfs2,
1467            Cfsamona_SPEC,
1468            crate::common::RW,
1469        >::from_register(self, 0)
1470    }
1471}
1472impl ::core::default::Default for Cfsamona {
1473    #[inline(always)]
1474    fn default() -> Cfsamona {
1475        <crate::RegValueT<Cfsamona_SPEC> as RegisterValue<_>>::new(0)
1476    }
1477}
1478pub mod cfsamona {
1479
1480    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1481    pub struct Cfs2_SPEC;
1482    pub type Cfs2 = crate::EnumBitfieldStruct<u8, Cfs2_SPEC>;
1483    impl Cfs2 {
1484        #[doc = "0 KB"]
1485        pub const _0_X_000: Self = Self::new(0);
1486
1487        #[doc = "32 KB"]
1488        pub const _0_X_001: Self = Self::new(1);
1489
1490        #[doc = "64 KB"]
1491        pub const _0_X_002: Self = Self::new(2);
1492
1493        #[doc = "96 KB"]
1494        pub const _0_X_003: Self = Self::new(3);
1495
1496        #[doc = "128 KB"]
1497        pub const _0_X_004: Self = Self::new(4);
1498    }
1499}
1500#[doc(hidden)]
1501#[derive(Copy, Clone, Eq, PartialEq)]
1502pub struct Cfsamonb_SPEC;
1503impl crate::sealed::RegSpec for Cfsamonb_SPEC {
1504    type DataType = u32;
1505}
1506
1507#[doc = "Code Flash Security Attribution Register B"]
1508pub type Cfsamonb = crate::RegValueT<Cfsamonb_SPEC>;
1509
1510impl Cfsamonb {
1511    #[doc = "Code Flash Secure area 1"]
1512    #[inline(always)]
1513    pub fn cfs1(
1514        self,
1515    ) -> crate::common::RegisterField<10, 0x3fff, 1, 0, u16, u16, Cfsamonb_SPEC, crate::common::RW>
1516    {
1517        crate::common::RegisterField::<10,0x3fff,1,0,u16,u16,Cfsamonb_SPEC,crate::common::RW>::from_register(self,0)
1518    }
1519}
1520impl ::core::default::Default for Cfsamonb {
1521    #[inline(always)]
1522    fn default() -> Cfsamonb {
1523        <crate::RegValueT<Cfsamonb_SPEC> as RegisterValue<_>>::new(0)
1524    }
1525}
1526
1527#[doc(hidden)]
1528#[derive(Copy, Clone, Eq, PartialEq)]
1529pub struct Dfsamon_SPEC;
1530impl crate::sealed::RegSpec for Dfsamon_SPEC {
1531    type DataType = u32;
1532}
1533
1534#[doc = "Data Flash Security Attribution Register"]
1535pub type Dfsamon = crate::RegValueT<Dfsamon_SPEC>;
1536
1537impl Dfsamon {
1538    #[doc = "Data flash Secure area"]
1539    #[inline(always)]
1540    pub fn dfs(
1541        self,
1542    ) -> crate::common::RegisterField<
1543        10,
1544        0x3f,
1545        1,
1546        0,
1547        dfsamon::Dfs,
1548        dfsamon::Dfs,
1549        Dfsamon_SPEC,
1550        crate::common::RW,
1551    > {
1552        crate::common::RegisterField::<
1553            10,
1554            0x3f,
1555            1,
1556            0,
1557            dfsamon::Dfs,
1558            dfsamon::Dfs,
1559            Dfsamon_SPEC,
1560            crate::common::RW,
1561        >::from_register(self, 0)
1562    }
1563}
1564impl ::core::default::Default for Dfsamon {
1565    #[inline(always)]
1566    fn default() -> Dfsamon {
1567        <crate::RegValueT<Dfsamon_SPEC> as RegisterValue<_>>::new(64512)
1568    }
1569}
1570pub mod dfsamon {
1571
1572    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1573    pub struct Dfs_SPEC;
1574    pub type Dfs = crate::EnumBitfieldStruct<u8, Dfs_SPEC>;
1575    impl Dfs {
1576        #[doc = "0 KB"]
1577        pub const _0_X_00: Self = Self::new(0);
1578
1579        #[doc = "1 KB"]
1580        pub const _0_X_01: Self = Self::new(1);
1581
1582        #[doc = "2 KB"]
1583        pub const _0_X_02: Self = Self::new(2);
1584
1585        #[doc = "3 KB"]
1586        pub const _0_X_03: Self = Self::new(3);
1587
1588        #[doc = "4 KB"]
1589        pub const _0_X_04: Self = Self::new(4);
1590
1591        #[doc = "Setting prohibited"]
1592        pub const OTHERS: Self = Self::new(0);
1593    }
1594}
1595#[doc(hidden)]
1596#[derive(Copy, Clone, Eq, PartialEq)]
1597pub struct Ssamona_SPEC;
1598impl crate::sealed::RegSpec for Ssamona_SPEC {
1599    type DataType = u32;
1600}
1601
1602#[doc = "SRAM Security Attribution Register A"]
1603pub type Ssamona = crate::RegValueT<Ssamona_SPEC>;
1604
1605impl Ssamona {
1606    #[doc = "SRAM Secure area 2"]
1607    #[inline(always)]
1608    pub fn ss2(
1609        self,
1610    ) -> crate::common::RegisterField<
1611        13,
1612        0xff,
1613        1,
1614        0,
1615        ssamona::Ss2,
1616        ssamona::Ss2,
1617        Ssamona_SPEC,
1618        crate::common::RW,
1619    > {
1620        crate::common::RegisterField::<
1621            13,
1622            0xff,
1623            1,
1624            0,
1625            ssamona::Ss2,
1626            ssamona::Ss2,
1627            Ssamona_SPEC,
1628            crate::common::RW,
1629        >::from_register(self, 0)
1630    }
1631}
1632impl ::core::default::Default for Ssamona {
1633    #[inline(always)]
1634    fn default() -> Ssamona {
1635        <crate::RegValueT<Ssamona_SPEC> as RegisterValue<_>>::new(2088960)
1636    }
1637}
1638pub mod ssamona {
1639
1640    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1641    pub struct Ss2_SPEC;
1642    pub type Ss2 = crate::EnumBitfieldStruct<u8, Ss2_SPEC>;
1643    impl Ss2 {
1644        #[doc = "0 KB"]
1645        pub const _0_X_000: Self = Self::new(0);
1646
1647        #[doc = "8 KB"]
1648        pub const _0_X_001: Self = Self::new(1);
1649
1650        #[doc = "16 KB"]
1651        pub const _0_X_002: Self = Self::new(2);
1652
1653        #[doc = "24 KB"]
1654        pub const _0_X_003: Self = Self::new(3);
1655
1656        #[doc = "32 KB"]
1657        pub const _0_X_004: Self = Self::new(4);
1658
1659        #[doc = "40 KB"]
1660        pub const _0_X_005: Self = Self::new(5);
1661
1662        #[doc = "Setting prohibited"]
1663        pub const OTHERS: Self = Self::new(0);
1664    }
1665}
1666#[doc(hidden)]
1667#[derive(Copy, Clone, Eq, PartialEq)]
1668pub struct Ssamonb_SPEC;
1669impl crate::sealed::RegSpec for Ssamonb_SPEC {
1670    type DataType = u32;
1671}
1672
1673#[doc = "SRAM Security Attribution Register B"]
1674pub type Ssamonb = crate::RegValueT<Ssamonb_SPEC>;
1675
1676impl Ssamonb {
1677    #[doc = "SRAM secure area 1"]
1678    #[inline(always)]
1679    pub fn ss1(
1680        self,
1681    ) -> crate::common::RegisterField<10, 0x7ff, 1, 0, u16, u16, Ssamonb_SPEC, crate::common::RW>
1682    {
1683        crate::common::RegisterField::<10,0x7ff,1,0,u16,u16,Ssamonb_SPEC,crate::common::RW>::from_register(self,0)
1684    }
1685}
1686impl ::core::default::Default for Ssamonb {
1687    #[inline(always)]
1688    fn default() -> Ssamonb {
1689        <crate::RegValueT<Ssamonb_SPEC> as RegisterValue<_>>::new(2096128)
1690    }
1691}
ra4e2_pac/pscu.rs

ra4e2_pac/
pscu.rs
