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

ra6m2_pac/
smpu.rs
