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

ra6e2_pac/
pscu.rs
