ra2a2_pac/
sram.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.20.02, with svd2pac 0.6.1 on Sun, 15 Mar 2026 07:01:00 +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"SRAM Control"]
28unsafe impl ::core::marker::Send for super::Sram {}
29unsafe impl ::core::marker::Sync for super::Sram {}
30impl super::Sram {
31    #[allow(unused)]
32    #[inline(always)]
33    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
34        self.ptr
35    }
36
37    #[doc = "SRAM Parity Error Operation After Detection Register"]
38    #[inline(always)]
39    pub const fn parioad(
40        &self,
41    ) -> &'static crate::common::Reg<self::Parioad_SPEC, crate::common::RW> {
42        unsafe {
43            crate::common::Reg::<self::Parioad_SPEC, crate::common::RW>::from_ptr(
44                self._svd2pac_as_ptr().add(0usize),
45            )
46        }
47    }
48
49    #[doc = "SRAM Protection Register"]
50    #[inline(always)]
51    pub const fn sramprcr(
52        &self,
53    ) -> &'static crate::common::Reg<self::Sramprcr_SPEC, crate::common::RW> {
54        unsafe {
55            crate::common::Reg::<self::Sramprcr_SPEC, crate::common::RW>::from_ptr(
56                self._svd2pac_as_ptr().add(4usize),
57            )
58        }
59    }
60
61    #[doc = "ECC Operating Mode Control Register"]
62    #[inline(always)]
63    pub const fn eccmode(
64        &self,
65    ) -> &'static crate::common::Reg<self::Eccmode_SPEC, crate::common::RW> {
66        unsafe {
67            crate::common::Reg::<self::Eccmode_SPEC, crate::common::RW>::from_ptr(
68                self._svd2pac_as_ptr().add(192usize),
69            )
70        }
71    }
72
73    #[doc = "ECC 2-Bit Error Status Register"]
74    #[inline(always)]
75    pub const fn ecc2sts(
76        &self,
77    ) -> &'static crate::common::Reg<self::Ecc2Sts_SPEC, crate::common::RW> {
78        unsafe {
79            crate::common::Reg::<self::Ecc2Sts_SPEC, crate::common::RW>::from_ptr(
80                self._svd2pac_as_ptr().add(193usize),
81            )
82        }
83    }
84
85    #[doc = "ECC 1-Bit Error Information Update Enable Register"]
86    #[inline(always)]
87    pub const fn ecc1stsen(
88        &self,
89    ) -> &'static crate::common::Reg<self::Ecc1Stsen_SPEC, crate::common::RW> {
90        unsafe {
91            crate::common::Reg::<self::Ecc1Stsen_SPEC, crate::common::RW>::from_ptr(
92                self._svd2pac_as_ptr().add(194usize),
93            )
94        }
95    }
96
97    #[doc = "ECC 1-Bit Error Status Register"]
98    #[inline(always)]
99    pub const fn ecc1sts(
100        &self,
101    ) -> &'static crate::common::Reg<self::Ecc1Sts_SPEC, crate::common::RW> {
102        unsafe {
103            crate::common::Reg::<self::Ecc1Sts_SPEC, crate::common::RW>::from_ptr(
104                self._svd2pac_as_ptr().add(195usize),
105            )
106        }
107    }
108
109    #[doc = "ECC Protection Register"]
110    #[inline(always)]
111    pub const fn eccprcr(
112        &self,
113    ) -> &'static crate::common::Reg<self::Eccprcr_SPEC, crate::common::RW> {
114        unsafe {
115            crate::common::Reg::<self::Eccprcr_SPEC, crate::common::RW>::from_ptr(
116                self._svd2pac_as_ptr().add(196usize),
117            )
118        }
119    }
120
121    #[doc = "ECC Protection Register 2"]
122    #[inline(always)]
123    pub const fn eccprcr2(
124        &self,
125    ) -> &'static crate::common::Reg<self::Eccprcr2_SPEC, crate::common::RW> {
126        unsafe {
127            crate::common::Reg::<self::Eccprcr2_SPEC, crate::common::RW>::from_ptr(
128                self._svd2pac_as_ptr().add(208usize),
129            )
130        }
131    }
132
133    #[doc = "ECC Test Control Register"]
134    #[inline(always)]
135    pub const fn eccetst(
136        &self,
137    ) -> &'static crate::common::Reg<self::Eccetst_SPEC, crate::common::RW> {
138        unsafe {
139            crate::common::Reg::<self::Eccetst_SPEC, crate::common::RW>::from_ptr(
140                self._svd2pac_as_ptr().add(212usize),
141            )
142        }
143    }
144
145    #[doc = "SRAM ECC Error Operation After Detection Register"]
146    #[inline(always)]
147    pub const fn eccoad(
148        &self,
149    ) -> &'static crate::common::Reg<self::Eccoad_SPEC, crate::common::RW> {
150        unsafe {
151            crate::common::Reg::<self::Eccoad_SPEC, crate::common::RW>::from_ptr(
152                self._svd2pac_as_ptr().add(216usize),
153            )
154        }
155    }
156}
157#[doc(hidden)]
158#[derive(Copy, Clone, Eq, PartialEq)]
159pub struct Parioad_SPEC;
160impl crate::sealed::RegSpec for Parioad_SPEC {
161    type DataType = u8;
162}
163
164#[doc = "SRAM Parity Error Operation After Detection Register"]
165pub type Parioad = crate::RegValueT<Parioad_SPEC>;
166
167impl Parioad {
168    #[doc = "Operation After Detection"]
169    #[inline(always)]
170    pub fn oad(
171        self,
172    ) -> crate::common::RegisterField<
173        0,
174        0x1,
175        1,
176        0,
177        parioad::Oad,
178        parioad::Oad,
179        Parioad_SPEC,
180        crate::common::RW,
181    > {
182        crate::common::RegisterField::<
183            0,
184            0x1,
185            1,
186            0,
187            parioad::Oad,
188            parioad::Oad,
189            Parioad_SPEC,
190            crate::common::RW,
191        >::from_register(self, 0)
192    }
193}
194impl ::core::default::Default for Parioad {
195    #[inline(always)]
196    fn default() -> Parioad {
197        <crate::RegValueT<Parioad_SPEC> as RegisterValue<_>>::new(0)
198    }
199}
200pub mod parioad {
201
202    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
203    pub struct Oad_SPEC;
204    pub type Oad = crate::EnumBitfieldStruct<u8, Oad_SPEC>;
205    impl Oad {
206        #[doc = "Non-maskable interrupt"]
207        pub const _0: Self = Self::new(0);
208
209        #[doc = "Reset"]
210        pub const _1: Self = Self::new(1);
211    }
212}
213#[doc(hidden)]
214#[derive(Copy, Clone, Eq, PartialEq)]
215pub struct Sramprcr_SPEC;
216impl crate::sealed::RegSpec for Sramprcr_SPEC {
217    type DataType = u8;
218}
219
220#[doc = "SRAM Protection Register"]
221pub type Sramprcr = crate::RegValueT<Sramprcr_SPEC>;
222
223impl Sramprcr {
224    #[doc = "Register Write Control"]
225    #[inline(always)]
226    pub fn sramprcr(
227        self,
228    ) -> crate::common::RegisterField<
229        0,
230        0x1,
231        1,
232        0,
233        sramprcr::Sramprcr,
234        sramprcr::Sramprcr,
235        Sramprcr_SPEC,
236        crate::common::RW,
237    > {
238        crate::common::RegisterField::<
239            0,
240            0x1,
241            1,
242            0,
243            sramprcr::Sramprcr,
244            sramprcr::Sramprcr,
245            Sramprcr_SPEC,
246            crate::common::RW,
247        >::from_register(self, 0)
248    }
249
250    #[doc = "Write Key Code"]
251    #[inline(always)]
252    pub fn kw(
253        self,
254    ) -> crate::common::RegisterField<1, 0x7f, 1, 0, u8, u8, Sramprcr_SPEC, crate::common::W> {
255        crate::common::RegisterField::<1,0x7f,1,0,u8,u8,Sramprcr_SPEC,crate::common::W>::from_register(self,0)
256    }
257}
258impl ::core::default::Default for Sramprcr {
259    #[inline(always)]
260    fn default() -> Sramprcr {
261        <crate::RegValueT<Sramprcr_SPEC> as RegisterValue<_>>::new(0)
262    }
263}
264pub mod sramprcr {
265
266    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
267    pub struct Sramprcr_SPEC;
268    pub type Sramprcr = crate::EnumBitfieldStruct<u8, Sramprcr_SPEC>;
269    impl Sramprcr {
270        #[doc = "Disable writes to protected registers"]
271        pub const _0: Self = Self::new(0);
272
273        #[doc = "Enable writes to protected registers"]
274        pub const _1: Self = Self::new(1);
275    }
276}
277#[doc(hidden)]
278#[derive(Copy, Clone, Eq, PartialEq)]
279pub struct Eccmode_SPEC;
280impl crate::sealed::RegSpec for Eccmode_SPEC {
281    type DataType = u8;
282}
283
284#[doc = "ECC Operating Mode Control Register"]
285pub type Eccmode = crate::RegValueT<Eccmode_SPEC>;
286
287impl Eccmode {
288    #[doc = "ECC Operating Mode Select"]
289    #[inline(always)]
290    pub fn eccmod(
291        self,
292    ) -> crate::common::RegisterField<
293        0,
294        0x3,
295        1,
296        0,
297        eccmode::Eccmod,
298        eccmode::Eccmod,
299        Eccmode_SPEC,
300        crate::common::RW,
301    > {
302        crate::common::RegisterField::<
303            0,
304            0x3,
305            1,
306            0,
307            eccmode::Eccmod,
308            eccmode::Eccmod,
309            Eccmode_SPEC,
310            crate::common::RW,
311        >::from_register(self, 0)
312    }
313}
314impl ::core::default::Default for Eccmode {
315    #[inline(always)]
316    fn default() -> Eccmode {
317        <crate::RegValueT<Eccmode_SPEC> as RegisterValue<_>>::new(0)
318    }
319}
320pub mod eccmode {
321
322    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
323    pub struct Eccmod_SPEC;
324    pub type Eccmod = crate::EnumBitfieldStruct<u8, Eccmod_SPEC>;
325    impl Eccmod {
326        #[doc = "Disable ECC function"]
327        pub const _00: Self = Self::new(0);
328
329        #[doc = "Setting prohibited"]
330        pub const _01: Self = Self::new(1);
331
332        #[doc = "Enable ECC function without error checking"]
333        pub const _10: Self = Self::new(2);
334
335        #[doc = "Enable ECC function with error checking"]
336        pub const _11: Self = Self::new(3);
337    }
338}
339#[doc(hidden)]
340#[derive(Copy, Clone, Eq, PartialEq)]
341pub struct Ecc2Sts_SPEC;
342impl crate::sealed::RegSpec for Ecc2Sts_SPEC {
343    type DataType = u8;
344}
345
346#[doc = "ECC 2-Bit Error Status Register"]
347pub type Ecc2Sts = crate::RegValueT<Ecc2Sts_SPEC>;
348
349impl Ecc2Sts {
350    #[doc = "ECC 2-Bit Error Status"]
351    #[inline(always)]
352    pub fn ecc2err(
353        self,
354    ) -> crate::common::RegisterField<
355        0,
356        0x1,
357        1,
358        0,
359        ecc2sts::Ecc2Err,
360        ecc2sts::Ecc2Err,
361        Ecc2Sts_SPEC,
362        crate::common::RW,
363    > {
364        crate::common::RegisterField::<
365            0,
366            0x1,
367            1,
368            0,
369            ecc2sts::Ecc2Err,
370            ecc2sts::Ecc2Err,
371            Ecc2Sts_SPEC,
372            crate::common::RW,
373        >::from_register(self, 0)
374    }
375}
376impl ::core::default::Default for Ecc2Sts {
377    #[inline(always)]
378    fn default() -> Ecc2Sts {
379        <crate::RegValueT<Ecc2Sts_SPEC> as RegisterValue<_>>::new(0)
380    }
381}
382pub mod ecc2sts {
383
384    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
385    pub struct Ecc2Err_SPEC;
386    pub type Ecc2Err = crate::EnumBitfieldStruct<u8, Ecc2Err_SPEC>;
387    impl Ecc2Err {
388        #[doc = "No 2-bit ECC error occurred"]
389        pub const _0: Self = Self::new(0);
390
391        #[doc = "2-bit ECC error occurred"]
392        pub const _1: Self = Self::new(1);
393    }
394}
395#[doc(hidden)]
396#[derive(Copy, Clone, Eq, PartialEq)]
397pub struct Ecc1Stsen_SPEC;
398impl crate::sealed::RegSpec for Ecc1Stsen_SPEC {
399    type DataType = u8;
400}
401
402#[doc = "ECC 1-Bit Error Information Update Enable Register"]
403pub type Ecc1Stsen = crate::RegValueT<Ecc1Stsen_SPEC>;
404
405impl Ecc1Stsen {
406    #[doc = "ECC 1-Bit Error Information Update Enable"]
407    #[inline(always)]
408    pub fn e1stsen(
409        self,
410    ) -> crate::common::RegisterField<
411        0,
412        0x1,
413        1,
414        0,
415        ecc1stsen::E1Stsen,
416        ecc1stsen::E1Stsen,
417        Ecc1Stsen_SPEC,
418        crate::common::RW,
419    > {
420        crate::common::RegisterField::<
421            0,
422            0x1,
423            1,
424            0,
425            ecc1stsen::E1Stsen,
426            ecc1stsen::E1Stsen,
427            Ecc1Stsen_SPEC,
428            crate::common::RW,
429        >::from_register(self, 0)
430    }
431}
432impl ::core::default::Default for Ecc1Stsen {
433    #[inline(always)]
434    fn default() -> Ecc1Stsen {
435        <crate::RegValueT<Ecc1Stsen_SPEC> as RegisterValue<_>>::new(0)
436    }
437}
438pub mod ecc1stsen {
439
440    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
441    pub struct E1Stsen_SPEC;
442    pub type E1Stsen = crate::EnumBitfieldStruct<u8, E1Stsen_SPEC>;
443    impl E1Stsen {
444        #[doc = "Disable updating of 1-bit ECC error information"]
445        pub const _0: Self = Self::new(0);
446
447        #[doc = "Enable updating of 1-bit ECC error information"]
448        pub const _1: Self = Self::new(1);
449    }
450}
451#[doc(hidden)]
452#[derive(Copy, Clone, Eq, PartialEq)]
453pub struct Ecc1Sts_SPEC;
454impl crate::sealed::RegSpec for Ecc1Sts_SPEC {
455    type DataType = u8;
456}
457
458#[doc = "ECC 1-Bit Error Status Register"]
459pub type Ecc1Sts = crate::RegValueT<Ecc1Sts_SPEC>;
460
461impl Ecc1Sts {
462    #[doc = "ECC 1-Bit Error Status"]
463    #[inline(always)]
464    pub fn ecc1err(
465        self,
466    ) -> crate::common::RegisterField<
467        0,
468        0x1,
469        1,
470        0,
471        ecc1sts::Ecc1Err,
472        ecc1sts::Ecc1Err,
473        Ecc1Sts_SPEC,
474        crate::common::RW,
475    > {
476        crate::common::RegisterField::<
477            0,
478            0x1,
479            1,
480            0,
481            ecc1sts::Ecc1Err,
482            ecc1sts::Ecc1Err,
483            Ecc1Sts_SPEC,
484            crate::common::RW,
485        >::from_register(self, 0)
486    }
487}
488impl ::core::default::Default for Ecc1Sts {
489    #[inline(always)]
490    fn default() -> Ecc1Sts {
491        <crate::RegValueT<Ecc1Sts_SPEC> as RegisterValue<_>>::new(0)
492    }
493}
494pub mod ecc1sts {
495
496    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
497    pub struct Ecc1Err_SPEC;
498    pub type Ecc1Err = crate::EnumBitfieldStruct<u8, Ecc1Err_SPEC>;
499    impl Ecc1Err {
500        #[doc = "No 1-bit ECC error occurred"]
501        pub const _0: Self = Self::new(0);
502
503        #[doc = "1-bit ECC error occurred"]
504        pub const _1: Self = Self::new(1);
505    }
506}
507#[doc(hidden)]
508#[derive(Copy, Clone, Eq, PartialEq)]
509pub struct Eccprcr_SPEC;
510impl crate::sealed::RegSpec for Eccprcr_SPEC {
511    type DataType = u8;
512}
513
514#[doc = "ECC Protection Register"]
515pub type Eccprcr = crate::RegValueT<Eccprcr_SPEC>;
516
517impl Eccprcr {
518    #[doc = "Register Write Control"]
519    #[inline(always)]
520    pub fn eccprcr(
521        self,
522    ) -> crate::common::RegisterField<
523        0,
524        0x1,
525        1,
526        0,
527        eccprcr::Eccprcr,
528        eccprcr::Eccprcr,
529        Eccprcr_SPEC,
530        crate::common::RW,
531    > {
532        crate::common::RegisterField::<
533            0,
534            0x1,
535            1,
536            0,
537            eccprcr::Eccprcr,
538            eccprcr::Eccprcr,
539            Eccprcr_SPEC,
540            crate::common::RW,
541        >::from_register(self, 0)
542    }
543
544    #[doc = "Write Key Code"]
545    #[inline(always)]
546    pub fn kw(
547        self,
548    ) -> crate::common::RegisterField<
549        1,
550        0x7f,
551        1,
552        0,
553        eccprcr::Kw,
554        eccprcr::Kw,
555        Eccprcr_SPEC,
556        crate::common::W,
557    > {
558        crate::common::RegisterField::<
559            1,
560            0x7f,
561            1,
562            0,
563            eccprcr::Kw,
564            eccprcr::Kw,
565            Eccprcr_SPEC,
566            crate::common::W,
567        >::from_register(self, 0)
568    }
569}
570impl ::core::default::Default for Eccprcr {
571    #[inline(always)]
572    fn default() -> Eccprcr {
573        <crate::RegValueT<Eccprcr_SPEC> as RegisterValue<_>>::new(0)
574    }
575}
576pub mod eccprcr {
577
578    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
579    pub struct Eccprcr_SPEC;
580    pub type Eccprcr = crate::EnumBitfieldStruct<u8, Eccprcr_SPEC>;
581    impl Eccprcr {
582        #[doc = "Disable writes to the protected registers"]
583        pub const _0: Self = Self::new(0);
584
585        #[doc = "Enable writes to the protected registers"]
586        pub const _1: Self = Self::new(1);
587    }
588    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
589    pub struct Kw_SPEC;
590    pub type Kw = crate::EnumBitfieldStruct<u8, Kw_SPEC>;
591    impl Kw {
592        #[doc = "Enable write to the ECCPRCR bit"]
593        pub const _0_X_78: Self = Self::new(120);
594    }
595}
596#[doc(hidden)]
597#[derive(Copy, Clone, Eq, PartialEq)]
598pub struct Eccprcr2_SPEC;
599impl crate::sealed::RegSpec for Eccprcr2_SPEC {
600    type DataType = u8;
601}
602
603#[doc = "ECC Protection Register 2"]
604pub type Eccprcr2 = crate::RegValueT<Eccprcr2_SPEC>;
605
606impl Eccprcr2 {
607    #[doc = "Register Write Control"]
608    #[inline(always)]
609    pub fn eccprcr2(
610        self,
611    ) -> crate::common::RegisterField<
612        0,
613        0x1,
614        1,
615        0,
616        eccprcr2::Eccprcr2,
617        eccprcr2::Eccprcr2,
618        Eccprcr2_SPEC,
619        crate::common::RW,
620    > {
621        crate::common::RegisterField::<
622            0,
623            0x1,
624            1,
625            0,
626            eccprcr2::Eccprcr2,
627            eccprcr2::Eccprcr2,
628            Eccprcr2_SPEC,
629            crate::common::RW,
630        >::from_register(self, 0)
631    }
632
633    #[doc = "Write Key Code"]
634    #[inline(always)]
635    pub fn kw2(
636        self,
637    ) -> crate::common::RegisterField<
638        1,
639        0x7f,
640        1,
641        0,
642        eccprcr2::Kw2,
643        eccprcr2::Kw2,
644        Eccprcr2_SPEC,
645        crate::common::W,
646    > {
647        crate::common::RegisterField::<
648            1,
649            0x7f,
650            1,
651            0,
652            eccprcr2::Kw2,
653            eccprcr2::Kw2,
654            Eccprcr2_SPEC,
655            crate::common::W,
656        >::from_register(self, 0)
657    }
658}
659impl ::core::default::Default for Eccprcr2 {
660    #[inline(always)]
661    fn default() -> Eccprcr2 {
662        <crate::RegValueT<Eccprcr2_SPEC> as RegisterValue<_>>::new(0)
663    }
664}
665pub mod eccprcr2 {
666
667    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
668    pub struct Eccprcr2_SPEC;
669    pub type Eccprcr2 = crate::EnumBitfieldStruct<u8, Eccprcr2_SPEC>;
670    impl Eccprcr2 {
671        #[doc = "Disable writes to the protected registers"]
672        pub const _0: Self = Self::new(0);
673
674        #[doc = "Enable writes to the protected registers"]
675        pub const _1: Self = Self::new(1);
676    }
677    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
678    pub struct Kw2_SPEC;
679    pub type Kw2 = crate::EnumBitfieldStruct<u8, Kw2_SPEC>;
680    impl Kw2 {
681        #[doc = "Enable write to the ECCPRCR2 bit"]
682        pub const _0_X_78: Self = Self::new(120);
683    }
684}
685#[doc(hidden)]
686#[derive(Copy, Clone, Eq, PartialEq)]
687pub struct Eccetst_SPEC;
688impl crate::sealed::RegSpec for Eccetst_SPEC {
689    type DataType = u8;
690}
691
692#[doc = "ECC Test Control Register"]
693pub type Eccetst = crate::RegValueT<Eccetst_SPEC>;
694
695impl Eccetst {
696    #[doc = "ECC Bypass Select"]
697    #[inline(always)]
698    pub fn tstbyp(
699        self,
700    ) -> crate::common::RegisterField<
701        0,
702        0x1,
703        1,
704        0,
705        eccetst::Tstbyp,
706        eccetst::Tstbyp,
707        Eccetst_SPEC,
708        crate::common::RW,
709    > {
710        crate::common::RegisterField::<
711            0,
712            0x1,
713            1,
714            0,
715            eccetst::Tstbyp,
716            eccetst::Tstbyp,
717            Eccetst_SPEC,
718            crate::common::RW,
719        >::from_register(self, 0)
720    }
721}
722impl ::core::default::Default for Eccetst {
723    #[inline(always)]
724    fn default() -> Eccetst {
725        <crate::RegValueT<Eccetst_SPEC> as RegisterValue<_>>::new(0)
726    }
727}
728pub mod eccetst {
729
730    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
731    pub struct Tstbyp_SPEC;
732    pub type Tstbyp = crate::EnumBitfieldStruct<u8, Tstbyp_SPEC>;
733    impl Tstbyp {
734        #[doc = "Disable ECC bypass"]
735        pub const _0: Self = Self::new(0);
736
737        #[doc = "Enable ECC bypass"]
738        pub const _1: Self = Self::new(1);
739    }
740}
741#[doc(hidden)]
742#[derive(Copy, Clone, Eq, PartialEq)]
743pub struct Eccoad_SPEC;
744impl crate::sealed::RegSpec for Eccoad_SPEC {
745    type DataType = u8;
746}
747
748#[doc = "SRAM ECC Error Operation After Detection Register"]
749pub type Eccoad = crate::RegValueT<Eccoad_SPEC>;
750
751impl Eccoad {
752    #[doc = "Operation After Detection"]
753    #[inline(always)]
754    pub fn oad(
755        self,
756    ) -> crate::common::RegisterField<
757        0,
758        0x1,
759        1,
760        0,
761        eccoad::Oad,
762        eccoad::Oad,
763        Eccoad_SPEC,
764        crate::common::RW,
765    > {
766        crate::common::RegisterField::<
767            0,
768            0x1,
769            1,
770            0,
771            eccoad::Oad,
772            eccoad::Oad,
773            Eccoad_SPEC,
774            crate::common::RW,
775        >::from_register(self, 0)
776    }
777}
778impl ::core::default::Default for Eccoad {
779    #[inline(always)]
780    fn default() -> Eccoad {
781        <crate::RegValueT<Eccoad_SPEC> as RegisterValue<_>>::new(0)
782    }
783}
784pub mod eccoad {
785
786    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
787    pub struct Oad_SPEC;
788    pub type Oad = crate::EnumBitfieldStruct<u8, Oad_SPEC>;
789    impl Oad {
790        #[doc = "Non-maskable interrupt"]
791        pub const _0: Self = Self::new(0);
792
793        #[doc = "Reset"]
794        pub const _1: Self = Self::new(1);
795    }
796}
ra2a2_pac/sram.rs

ra2a2_pac/
sram.rs
