mimxrt685s_pac/sysctl0/
dsp_sram_access_disable.rs

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

mimxrt685s_pac/sysctl0/
dsp_sram_access_disable.rs
