mimxrt685s_pac/sysctl0/
pdruncfg2_clr.rs

1#[doc = "Register `PDRUNCFG2_CLR` writer"]
2pub type W = crate::W<Pdruncfg2ClrSpec>;
3#[doc = "Array Power\n\nValue on reset: 0"]
4#[cfg_attr(feature = "defmt", derive(defmt::Format))]
5#[derive(Clone, Copy, Debug, PartialEq, Eq)]
6pub enum SramIf0Apd {
7    #[doc = "0: No effect"]
8    NoEffect = 0,
9    #[doc = "1: Clears the PDRUNCFG2 Bit"]
10    ClrPdruncfg2 = 1,
11}
12impl From<SramIf0Apd> for bool {
13    #[inline(always)]
14    fn from(variant: SramIf0Apd) -> Self {
15        variant as u8 != 0
16    }
17}
18#[doc = "Field `SRAM_IF0_APD` writer - Array Power"]
19pub type SramIf0ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf0Apd>;
20impl<'a, REG> SramIf0ApdW<'a, REG>
21where
22    REG: crate::Writable + crate::RegisterSpec,
23{
24    #[doc = "No effect"]
25    #[inline(always)]
26    pub fn no_effect(self) -> &'a mut crate::W<REG> {
27        self.variant(SramIf0Apd::NoEffect)
28    }
29    #[doc = "Clears the PDRUNCFG2 Bit"]
30    #[inline(always)]
31    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
32        self.variant(SramIf0Apd::ClrPdruncfg2)
33    }
34}
35#[doc = "Array Power\n\nValue on reset: 0"]
36#[cfg_attr(feature = "defmt", derive(defmt::Format))]
37#[derive(Clone, Copy, Debug, PartialEq, Eq)]
38pub enum SramIf1Apd {
39    #[doc = "0: No effect"]
40    NoEffect = 0,
41    #[doc = "1: Clears the PDRUNCFG2 Bit"]
42    ClrPdruncfg2 = 1,
43}
44impl From<SramIf1Apd> for bool {
45    #[inline(always)]
46    fn from(variant: SramIf1Apd) -> Self {
47        variant as u8 != 0
48    }
49}
50#[doc = "Field `SRAM_IF1_APD` writer - Array Power"]
51pub type SramIf1ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf1Apd>;
52impl<'a, REG> SramIf1ApdW<'a, REG>
53where
54    REG: crate::Writable + crate::RegisterSpec,
55{
56    #[doc = "No effect"]
57    #[inline(always)]
58    pub fn no_effect(self) -> &'a mut crate::W<REG> {
59        self.variant(SramIf1Apd::NoEffect)
60    }
61    #[doc = "Clears the PDRUNCFG2 Bit"]
62    #[inline(always)]
63    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
64        self.variant(SramIf1Apd::ClrPdruncfg2)
65    }
66}
67#[doc = "Array Power\n\nValue on reset: 0"]
68#[cfg_attr(feature = "defmt", derive(defmt::Format))]
69#[derive(Clone, Copy, Debug, PartialEq, Eq)]
70pub enum SramIf2Apd {
71    #[doc = "0: No effect"]
72    NoEffect = 0,
73    #[doc = "1: Clears the PDRUNCFG2 Bit"]
74    ClrPdruncfg2 = 1,
75}
76impl From<SramIf2Apd> for bool {
77    #[inline(always)]
78    fn from(variant: SramIf2Apd) -> Self {
79        variant as u8 != 0
80    }
81}
82#[doc = "Field `SRAM_IF2_APD` writer - Array Power"]
83pub type SramIf2ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf2Apd>;
84impl<'a, REG> SramIf2ApdW<'a, REG>
85where
86    REG: crate::Writable + crate::RegisterSpec,
87{
88    #[doc = "No effect"]
89    #[inline(always)]
90    pub fn no_effect(self) -> &'a mut crate::W<REG> {
91        self.variant(SramIf2Apd::NoEffect)
92    }
93    #[doc = "Clears the PDRUNCFG2 Bit"]
94    #[inline(always)]
95    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
96        self.variant(SramIf2Apd::ClrPdruncfg2)
97    }
98}
99#[doc = "Array Power\n\nValue on reset: 0"]
100#[cfg_attr(feature = "defmt", derive(defmt::Format))]
101#[derive(Clone, Copy, Debug, PartialEq, Eq)]
102pub enum SramIf3Apd {
103    #[doc = "0: No effect"]
104    NoEffect = 0,
105    #[doc = "1: Clears the PDRUNCFG2 Bit"]
106    ClrPdruncfg2 = 1,
107}
108impl From<SramIf3Apd> for bool {
109    #[inline(always)]
110    fn from(variant: SramIf3Apd) -> Self {
111        variant as u8 != 0
112    }
113}
114#[doc = "Field `SRAM_IF3_APD` writer - Array Power"]
115pub type SramIf3ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf3Apd>;
116impl<'a, REG> SramIf3ApdW<'a, REG>
117where
118    REG: crate::Writable + crate::RegisterSpec,
119{
120    #[doc = "No effect"]
121    #[inline(always)]
122    pub fn no_effect(self) -> &'a mut crate::W<REG> {
123        self.variant(SramIf3Apd::NoEffect)
124    }
125    #[doc = "Clears the PDRUNCFG2 Bit"]
126    #[inline(always)]
127    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
128        self.variant(SramIf3Apd::ClrPdruncfg2)
129    }
130}
131#[doc = "Array Power\n\nValue on reset: 0"]
132#[cfg_attr(feature = "defmt", derive(defmt::Format))]
133#[derive(Clone, Copy, Debug, PartialEq, Eq)]
134pub enum SramIf4Apd {
135    #[doc = "0: No effect"]
136    NoEffect = 0,
137    #[doc = "1: Clears the PDRUNCFG2 Bit"]
138    ClrPdruncfg2 = 1,
139}
140impl From<SramIf4Apd> for bool {
141    #[inline(always)]
142    fn from(variant: SramIf4Apd) -> Self {
143        variant as u8 != 0
144    }
145}
146#[doc = "Field `SRAM_IF4_APD` writer - Array Power"]
147pub type SramIf4ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf4Apd>;
148impl<'a, REG> SramIf4ApdW<'a, REG>
149where
150    REG: crate::Writable + crate::RegisterSpec,
151{
152    #[doc = "No effect"]
153    #[inline(always)]
154    pub fn no_effect(self) -> &'a mut crate::W<REG> {
155        self.variant(SramIf4Apd::NoEffect)
156    }
157    #[doc = "Clears the PDRUNCFG2 Bit"]
158    #[inline(always)]
159    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
160        self.variant(SramIf4Apd::ClrPdruncfg2)
161    }
162}
163#[doc = "Array Power\n\nValue on reset: 0"]
164#[cfg_attr(feature = "defmt", derive(defmt::Format))]
165#[derive(Clone, Copy, Debug, PartialEq, Eq)]
166pub enum SramIf5Apd {
167    #[doc = "0: No effect"]
168    NoEffect = 0,
169    #[doc = "1: Clears the PDRUNCFG2 Bit"]
170    ClrPdruncfg2 = 1,
171}
172impl From<SramIf5Apd> for bool {
173    #[inline(always)]
174    fn from(variant: SramIf5Apd) -> Self {
175        variant as u8 != 0
176    }
177}
178#[doc = "Field `SRAM_IF5_APD` writer - Array Power"]
179pub type SramIf5ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf5Apd>;
180impl<'a, REG> SramIf5ApdW<'a, REG>
181where
182    REG: crate::Writable + crate::RegisterSpec,
183{
184    #[doc = "No effect"]
185    #[inline(always)]
186    pub fn no_effect(self) -> &'a mut crate::W<REG> {
187        self.variant(SramIf5Apd::NoEffect)
188    }
189    #[doc = "Clears the PDRUNCFG2 Bit"]
190    #[inline(always)]
191    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
192        self.variant(SramIf5Apd::ClrPdruncfg2)
193    }
194}
195#[doc = "Array Power\n\nValue on reset: 0"]
196#[cfg_attr(feature = "defmt", derive(defmt::Format))]
197#[derive(Clone, Copy, Debug, PartialEq, Eq)]
198pub enum SramIf6Apd {
199    #[doc = "0: No effect"]
200    NoEffect = 0,
201    #[doc = "1: Clears the PDRUNCFG2 Bit"]
202    ClrPdruncfg2 = 1,
203}
204impl From<SramIf6Apd> for bool {
205    #[inline(always)]
206    fn from(variant: SramIf6Apd) -> Self {
207        variant as u8 != 0
208    }
209}
210#[doc = "Field `SRAM_IF6_APD` writer - Array Power"]
211pub type SramIf6ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf6Apd>;
212impl<'a, REG> SramIf6ApdW<'a, REG>
213where
214    REG: crate::Writable + crate::RegisterSpec,
215{
216    #[doc = "No effect"]
217    #[inline(always)]
218    pub fn no_effect(self) -> &'a mut crate::W<REG> {
219        self.variant(SramIf6Apd::NoEffect)
220    }
221    #[doc = "Clears the PDRUNCFG2 Bit"]
222    #[inline(always)]
223    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
224        self.variant(SramIf6Apd::ClrPdruncfg2)
225    }
226}
227#[doc = "Array Power\n\nValue on reset: 0"]
228#[cfg_attr(feature = "defmt", derive(defmt::Format))]
229#[derive(Clone, Copy, Debug, PartialEq, Eq)]
230pub enum SramIf7Apd {
231    #[doc = "0: No effect"]
232    NoEffect = 0,
233    #[doc = "1: Clears the PDRUNCFG2 Bit"]
234    ClrPdruncfg2 = 1,
235}
236impl From<SramIf7Apd> for bool {
237    #[inline(always)]
238    fn from(variant: SramIf7Apd) -> Self {
239        variant as u8 != 0
240    }
241}
242#[doc = "Field `SRAM_IF7_APD` writer - Array Power"]
243pub type SramIf7ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf7Apd>;
244impl<'a, REG> SramIf7ApdW<'a, REG>
245where
246    REG: crate::Writable + crate::RegisterSpec,
247{
248    #[doc = "No effect"]
249    #[inline(always)]
250    pub fn no_effect(self) -> &'a mut crate::W<REG> {
251        self.variant(SramIf7Apd::NoEffect)
252    }
253    #[doc = "Clears the PDRUNCFG2 Bit"]
254    #[inline(always)]
255    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
256        self.variant(SramIf7Apd::ClrPdruncfg2)
257    }
258}
259#[doc = "Array Power\n\nValue on reset: 0"]
260#[cfg_attr(feature = "defmt", derive(defmt::Format))]
261#[derive(Clone, Copy, Debug, PartialEq, Eq)]
262pub enum SramIf8Apd {
263    #[doc = "0: No effect"]
264    NoEffect = 0,
265    #[doc = "1: Clears the PDRUNCFG2 Bit"]
266    ClrPdruncfg2 = 1,
267}
268impl From<SramIf8Apd> for bool {
269    #[inline(always)]
270    fn from(variant: SramIf8Apd) -> Self {
271        variant as u8 != 0
272    }
273}
274#[doc = "Field `SRAM_IF8_APD` writer - Array Power"]
275pub type SramIf8ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf8Apd>;
276impl<'a, REG> SramIf8ApdW<'a, REG>
277where
278    REG: crate::Writable + crate::RegisterSpec,
279{
280    #[doc = "No effect"]
281    #[inline(always)]
282    pub fn no_effect(self) -> &'a mut crate::W<REG> {
283        self.variant(SramIf8Apd::NoEffect)
284    }
285    #[doc = "Clears the PDRUNCFG2 Bit"]
286    #[inline(always)]
287    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
288        self.variant(SramIf8Apd::ClrPdruncfg2)
289    }
290}
291#[doc = "Array Power\n\nValue on reset: 0"]
292#[cfg_attr(feature = "defmt", derive(defmt::Format))]
293#[derive(Clone, Copy, Debug, PartialEq, Eq)]
294pub enum SramIf9Apd {
295    #[doc = "0: No effect"]
296    NoEffect = 0,
297    #[doc = "1: Clears the PDRUNCFG2 Bit"]
298    ClrPdruncfg2 = 1,
299}
300impl From<SramIf9Apd> for bool {
301    #[inline(always)]
302    fn from(variant: SramIf9Apd) -> Self {
303        variant as u8 != 0
304    }
305}
306#[doc = "Field `SRAM_IF9_APD` writer - Array Power"]
307pub type SramIf9ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf9Apd>;
308impl<'a, REG> SramIf9ApdW<'a, REG>
309where
310    REG: crate::Writable + crate::RegisterSpec,
311{
312    #[doc = "No effect"]
313    #[inline(always)]
314    pub fn no_effect(self) -> &'a mut crate::W<REG> {
315        self.variant(SramIf9Apd::NoEffect)
316    }
317    #[doc = "Clears the PDRUNCFG2 Bit"]
318    #[inline(always)]
319    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
320        self.variant(SramIf9Apd::ClrPdruncfg2)
321    }
322}
323#[doc = "Array Power\n\nValue on reset: 0"]
324#[cfg_attr(feature = "defmt", derive(defmt::Format))]
325#[derive(Clone, Copy, Debug, PartialEq, Eq)]
326pub enum SramIf10Apd {
327    #[doc = "0: No effect"]
328    NoEffect = 0,
329    #[doc = "1: Clears the PDRUNCFG2 Bit"]
330    ClrPdruncfg2 = 1,
331}
332impl From<SramIf10Apd> for bool {
333    #[inline(always)]
334    fn from(variant: SramIf10Apd) -> Self {
335        variant as u8 != 0
336    }
337}
338#[doc = "Field `SRAM_IF10_APD` writer - Array Power"]
339pub type SramIf10ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf10Apd>;
340impl<'a, REG> SramIf10ApdW<'a, REG>
341where
342    REG: crate::Writable + crate::RegisterSpec,
343{
344    #[doc = "No effect"]
345    #[inline(always)]
346    pub fn no_effect(self) -> &'a mut crate::W<REG> {
347        self.variant(SramIf10Apd::NoEffect)
348    }
349    #[doc = "Clears the PDRUNCFG2 Bit"]
350    #[inline(always)]
351    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
352        self.variant(SramIf10Apd::ClrPdruncfg2)
353    }
354}
355#[doc = "Array Power\n\nValue on reset: 0"]
356#[cfg_attr(feature = "defmt", derive(defmt::Format))]
357#[derive(Clone, Copy, Debug, PartialEq, Eq)]
358pub enum SramIf11Apd {
359    #[doc = "0: No effect"]
360    NoEffect = 0,
361    #[doc = "1: Clears the PDRUNCFG2 Bit"]
362    ClrPdruncfg2 = 1,
363}
364impl From<SramIf11Apd> for bool {
365    #[inline(always)]
366    fn from(variant: SramIf11Apd) -> Self {
367        variant as u8 != 0
368    }
369}
370#[doc = "Field `SRAM_IF11_APD` writer - Array Power"]
371pub type SramIf11ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf11Apd>;
372impl<'a, REG> SramIf11ApdW<'a, REG>
373where
374    REG: crate::Writable + crate::RegisterSpec,
375{
376    #[doc = "No effect"]
377    #[inline(always)]
378    pub fn no_effect(self) -> &'a mut crate::W<REG> {
379        self.variant(SramIf11Apd::NoEffect)
380    }
381    #[doc = "Clears the PDRUNCFG2 Bit"]
382    #[inline(always)]
383    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
384        self.variant(SramIf11Apd::ClrPdruncfg2)
385    }
386}
387#[doc = "Array Power\n\nValue on reset: 0"]
388#[cfg_attr(feature = "defmt", derive(defmt::Format))]
389#[derive(Clone, Copy, Debug, PartialEq, Eq)]
390pub enum SramIf12Apd {
391    #[doc = "0: No effect"]
392    NoEffect = 0,
393    #[doc = "1: Clears the PDRUNCFG2 Bit"]
394    ClrPdruncfg2 = 1,
395}
396impl From<SramIf12Apd> for bool {
397    #[inline(always)]
398    fn from(variant: SramIf12Apd) -> Self {
399        variant as u8 != 0
400    }
401}
402#[doc = "Field `SRAM_IF12_APD` writer - Array Power"]
403pub type SramIf12ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf12Apd>;
404impl<'a, REG> SramIf12ApdW<'a, REG>
405where
406    REG: crate::Writable + crate::RegisterSpec,
407{
408    #[doc = "No effect"]
409    #[inline(always)]
410    pub fn no_effect(self) -> &'a mut crate::W<REG> {
411        self.variant(SramIf12Apd::NoEffect)
412    }
413    #[doc = "Clears the PDRUNCFG2 Bit"]
414    #[inline(always)]
415    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
416        self.variant(SramIf12Apd::ClrPdruncfg2)
417    }
418}
419#[doc = "Array Power\n\nValue on reset: 0"]
420#[cfg_attr(feature = "defmt", derive(defmt::Format))]
421#[derive(Clone, Copy, Debug, PartialEq, Eq)]
422pub enum SramIf13Apd {
423    #[doc = "0: No effect"]
424    NoEffect = 0,
425    #[doc = "1: Clears the PDRUNCFG2 Bit"]
426    ClrPdruncfg2 = 1,
427}
428impl From<SramIf13Apd> for bool {
429    #[inline(always)]
430    fn from(variant: SramIf13Apd) -> Self {
431        variant as u8 != 0
432    }
433}
434#[doc = "Field `SRAM_IF13_APD` writer - Array Power"]
435pub type SramIf13ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf13Apd>;
436impl<'a, REG> SramIf13ApdW<'a, REG>
437where
438    REG: crate::Writable + crate::RegisterSpec,
439{
440    #[doc = "No effect"]
441    #[inline(always)]
442    pub fn no_effect(self) -> &'a mut crate::W<REG> {
443        self.variant(SramIf13Apd::NoEffect)
444    }
445    #[doc = "Clears the PDRUNCFG2 Bit"]
446    #[inline(always)]
447    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
448        self.variant(SramIf13Apd::ClrPdruncfg2)
449    }
450}
451#[doc = "Array Power\n\nValue on reset: 0"]
452#[cfg_attr(feature = "defmt", derive(defmt::Format))]
453#[derive(Clone, Copy, Debug, PartialEq, Eq)]
454pub enum SramIf14Apd {
455    #[doc = "0: No effect"]
456    NoEffect = 0,
457    #[doc = "1: Clears the PDRUNCFG2 Bit"]
458    ClrPdruncfg2 = 1,
459}
460impl From<SramIf14Apd> for bool {
461    #[inline(always)]
462    fn from(variant: SramIf14Apd) -> Self {
463        variant as u8 != 0
464    }
465}
466#[doc = "Field `SRAM_IF14_APD` writer - Array Power"]
467pub type SramIf14ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf14Apd>;
468impl<'a, REG> SramIf14ApdW<'a, REG>
469where
470    REG: crate::Writable + crate::RegisterSpec,
471{
472    #[doc = "No effect"]
473    #[inline(always)]
474    pub fn no_effect(self) -> &'a mut crate::W<REG> {
475        self.variant(SramIf14Apd::NoEffect)
476    }
477    #[doc = "Clears the PDRUNCFG2 Bit"]
478    #[inline(always)]
479    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
480        self.variant(SramIf14Apd::ClrPdruncfg2)
481    }
482}
483#[doc = "Array Power\n\nValue on reset: 0"]
484#[cfg_attr(feature = "defmt", derive(defmt::Format))]
485#[derive(Clone, Copy, Debug, PartialEq, Eq)]
486pub enum SramIf15Apd {
487    #[doc = "0: No effect"]
488    NoEffect = 0,
489    #[doc = "1: Clears the PDRUNCFG2 Bit"]
490    ClrPdruncfg2 = 1,
491}
492impl From<SramIf15Apd> for bool {
493    #[inline(always)]
494    fn from(variant: SramIf15Apd) -> Self {
495        variant as u8 != 0
496    }
497}
498#[doc = "Field `SRAM_IF15_APD` writer - Array Power"]
499pub type SramIf15ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf15Apd>;
500impl<'a, REG> SramIf15ApdW<'a, REG>
501where
502    REG: crate::Writable + crate::RegisterSpec,
503{
504    #[doc = "No effect"]
505    #[inline(always)]
506    pub fn no_effect(self) -> &'a mut crate::W<REG> {
507        self.variant(SramIf15Apd::NoEffect)
508    }
509    #[doc = "Clears the PDRUNCFG2 Bit"]
510    #[inline(always)]
511    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
512        self.variant(SramIf15Apd::ClrPdruncfg2)
513    }
514}
515#[doc = "Array Power\n\nValue on reset: 0"]
516#[cfg_attr(feature = "defmt", derive(defmt::Format))]
517#[derive(Clone, Copy, Debug, PartialEq, Eq)]
518pub enum SramIf16Apd {
519    #[doc = "0: No effect"]
520    NoEffect = 0,
521    #[doc = "1: Clears the PDRUNCFG2 Bit"]
522    ClrPdruncfg2 = 1,
523}
524impl From<SramIf16Apd> for bool {
525    #[inline(always)]
526    fn from(variant: SramIf16Apd) -> Self {
527        variant as u8 != 0
528    }
529}
530#[doc = "Field `SRAM_IF16_APD` writer - Array Power"]
531pub type SramIf16ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf16Apd>;
532impl<'a, REG> SramIf16ApdW<'a, REG>
533where
534    REG: crate::Writable + crate::RegisterSpec,
535{
536    #[doc = "No effect"]
537    #[inline(always)]
538    pub fn no_effect(self) -> &'a mut crate::W<REG> {
539        self.variant(SramIf16Apd::NoEffect)
540    }
541    #[doc = "Clears the PDRUNCFG2 Bit"]
542    #[inline(always)]
543    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
544        self.variant(SramIf16Apd::ClrPdruncfg2)
545    }
546}
547#[doc = "Array Power\n\nValue on reset: 0"]
548#[cfg_attr(feature = "defmt", derive(defmt::Format))]
549#[derive(Clone, Copy, Debug, PartialEq, Eq)]
550pub enum SramIf17Apd {
551    #[doc = "0: No effect"]
552    NoEffect = 0,
553    #[doc = "1: Clears the PDRUNCFG2 Bit"]
554    ClrPdruncfg2 = 1,
555}
556impl From<SramIf17Apd> for bool {
557    #[inline(always)]
558    fn from(variant: SramIf17Apd) -> Self {
559        variant as u8 != 0
560    }
561}
562#[doc = "Field `SRAM_IF17_APD` writer - Array Power"]
563pub type SramIf17ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf17Apd>;
564impl<'a, REG> SramIf17ApdW<'a, REG>
565where
566    REG: crate::Writable + crate::RegisterSpec,
567{
568    #[doc = "No effect"]
569    #[inline(always)]
570    pub fn no_effect(self) -> &'a mut crate::W<REG> {
571        self.variant(SramIf17Apd::NoEffect)
572    }
573    #[doc = "Clears the PDRUNCFG2 Bit"]
574    #[inline(always)]
575    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
576        self.variant(SramIf17Apd::ClrPdruncfg2)
577    }
578}
579#[doc = "Array Power\n\nValue on reset: 0"]
580#[cfg_attr(feature = "defmt", derive(defmt::Format))]
581#[derive(Clone, Copy, Debug, PartialEq, Eq)]
582pub enum SramIf18Apd {
583    #[doc = "0: No effect"]
584    NoEffect = 0,
585    #[doc = "1: Clears the PDRUNCFG2 Bit"]
586    ClrPdruncfg2 = 1,
587}
588impl From<SramIf18Apd> for bool {
589    #[inline(always)]
590    fn from(variant: SramIf18Apd) -> Self {
591        variant as u8 != 0
592    }
593}
594#[doc = "Field `SRAM_IF18_APD` writer - Array Power"]
595pub type SramIf18ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf18Apd>;
596impl<'a, REG> SramIf18ApdW<'a, REG>
597where
598    REG: crate::Writable + crate::RegisterSpec,
599{
600    #[doc = "No effect"]
601    #[inline(always)]
602    pub fn no_effect(self) -> &'a mut crate::W<REG> {
603        self.variant(SramIf18Apd::NoEffect)
604    }
605    #[doc = "Clears the PDRUNCFG2 Bit"]
606    #[inline(always)]
607    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
608        self.variant(SramIf18Apd::ClrPdruncfg2)
609    }
610}
611#[doc = "Array Power\n\nValue on reset: 0"]
612#[cfg_attr(feature = "defmt", derive(defmt::Format))]
613#[derive(Clone, Copy, Debug, PartialEq, Eq)]
614pub enum SramIf19Apd {
615    #[doc = "0: No effect"]
616    NoEffect = 0,
617    #[doc = "1: Clears the PDRUNCFG2 Bit"]
618    ClrPdruncfg2 = 1,
619}
620impl From<SramIf19Apd> for bool {
621    #[inline(always)]
622    fn from(variant: SramIf19Apd) -> Self {
623        variant as u8 != 0
624    }
625}
626#[doc = "Field `SRAM_IF19_APD` writer - Array Power"]
627pub type SramIf19ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf19Apd>;
628impl<'a, REG> SramIf19ApdW<'a, REG>
629where
630    REG: crate::Writable + crate::RegisterSpec,
631{
632    #[doc = "No effect"]
633    #[inline(always)]
634    pub fn no_effect(self) -> &'a mut crate::W<REG> {
635        self.variant(SramIf19Apd::NoEffect)
636    }
637    #[doc = "Clears the PDRUNCFG2 Bit"]
638    #[inline(always)]
639    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
640        self.variant(SramIf19Apd::ClrPdruncfg2)
641    }
642}
643#[doc = "Array Power\n\nValue on reset: 0"]
644#[cfg_attr(feature = "defmt", derive(defmt::Format))]
645#[derive(Clone, Copy, Debug, PartialEq, Eq)]
646pub enum SramIf20Apd {
647    #[doc = "0: No effect"]
648    NoEffect = 0,
649    #[doc = "1: Clears the PDRUNCFG2 Bit"]
650    ClrPdruncfg2 = 1,
651}
652impl From<SramIf20Apd> for bool {
653    #[inline(always)]
654    fn from(variant: SramIf20Apd) -> Self {
655        variant as u8 != 0
656    }
657}
658#[doc = "Field `SRAM_IF20_APD` writer - Array Power"]
659pub type SramIf20ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf20Apd>;
660impl<'a, REG> SramIf20ApdW<'a, REG>
661where
662    REG: crate::Writable + crate::RegisterSpec,
663{
664    #[doc = "No effect"]
665    #[inline(always)]
666    pub fn no_effect(self) -> &'a mut crate::W<REG> {
667        self.variant(SramIf20Apd::NoEffect)
668    }
669    #[doc = "Clears the PDRUNCFG2 Bit"]
670    #[inline(always)]
671    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
672        self.variant(SramIf20Apd::ClrPdruncfg2)
673    }
674}
675#[doc = "Array Power\n\nValue on reset: 0"]
676#[cfg_attr(feature = "defmt", derive(defmt::Format))]
677#[derive(Clone, Copy, Debug, PartialEq, Eq)]
678pub enum SramIf21Apd {
679    #[doc = "0: No effect"]
680    NoEffect = 0,
681    #[doc = "1: Clears the PDRUNCFG2 Bit"]
682    ClrPdruncfg2 = 1,
683}
684impl From<SramIf21Apd> for bool {
685    #[inline(always)]
686    fn from(variant: SramIf21Apd) -> Self {
687        variant as u8 != 0
688    }
689}
690#[doc = "Field `SRAM_IF21_APD` writer - Array Power"]
691pub type SramIf21ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf21Apd>;
692impl<'a, REG> SramIf21ApdW<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "No effect"]
697    #[inline(always)]
698    pub fn no_effect(self) -> &'a mut crate::W<REG> {
699        self.variant(SramIf21Apd::NoEffect)
700    }
701    #[doc = "Clears the PDRUNCFG2 Bit"]
702    #[inline(always)]
703    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
704        self.variant(SramIf21Apd::ClrPdruncfg2)
705    }
706}
707#[doc = "Array Power\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum SramIf22Apd {
711    #[doc = "0: No effect"]
712    NoEffect = 0,
713    #[doc = "1: Clears the PDRUNCFG2 Bit"]
714    ClrPdruncfg2 = 1,
715}
716impl From<SramIf22Apd> for bool {
717    #[inline(always)]
718    fn from(variant: SramIf22Apd) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `SRAM_IF22_APD` writer - Array Power"]
723pub type SramIf22ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf22Apd>;
724impl<'a, REG> SramIf22ApdW<'a, REG>
725where
726    REG: crate::Writable + crate::RegisterSpec,
727{
728    #[doc = "No effect"]
729    #[inline(always)]
730    pub fn no_effect(self) -> &'a mut crate::W<REG> {
731        self.variant(SramIf22Apd::NoEffect)
732    }
733    #[doc = "Clears the PDRUNCFG2 Bit"]
734    #[inline(always)]
735    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
736        self.variant(SramIf22Apd::ClrPdruncfg2)
737    }
738}
739#[doc = "Array Power\n\nValue on reset: 0"]
740#[cfg_attr(feature = "defmt", derive(defmt::Format))]
741#[derive(Clone, Copy, Debug, PartialEq, Eq)]
742pub enum SramIf23Apd {
743    #[doc = "0: No effect"]
744    NoEffect = 0,
745    #[doc = "1: Clears the PDRUNCFG2 Bit"]
746    ClrPdruncfg2 = 1,
747}
748impl From<SramIf23Apd> for bool {
749    #[inline(always)]
750    fn from(variant: SramIf23Apd) -> Self {
751        variant as u8 != 0
752    }
753}
754#[doc = "Field `SRAM_IF23_APD` writer - Array Power"]
755pub type SramIf23ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf23Apd>;
756impl<'a, REG> SramIf23ApdW<'a, REG>
757where
758    REG: crate::Writable + crate::RegisterSpec,
759{
760    #[doc = "No effect"]
761    #[inline(always)]
762    pub fn no_effect(self) -> &'a mut crate::W<REG> {
763        self.variant(SramIf23Apd::NoEffect)
764    }
765    #[doc = "Clears the PDRUNCFG2 Bit"]
766    #[inline(always)]
767    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
768        self.variant(SramIf23Apd::ClrPdruncfg2)
769    }
770}
771#[doc = "Array Power\n\nValue on reset: 0"]
772#[cfg_attr(feature = "defmt", derive(defmt::Format))]
773#[derive(Clone, Copy, Debug, PartialEq, Eq)]
774pub enum SramIf24Apd {
775    #[doc = "0: No effect"]
776    NoEffect = 0,
777    #[doc = "1: Clears the PDRUNCFG2 Bit"]
778    ClrPdruncfg2 = 1,
779}
780impl From<SramIf24Apd> for bool {
781    #[inline(always)]
782    fn from(variant: SramIf24Apd) -> Self {
783        variant as u8 != 0
784    }
785}
786#[doc = "Field `SRAM_IF24_APD` writer - Array Power"]
787pub type SramIf24ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf24Apd>;
788impl<'a, REG> SramIf24ApdW<'a, REG>
789where
790    REG: crate::Writable + crate::RegisterSpec,
791{
792    #[doc = "No effect"]
793    #[inline(always)]
794    pub fn no_effect(self) -> &'a mut crate::W<REG> {
795        self.variant(SramIf24Apd::NoEffect)
796    }
797    #[doc = "Clears the PDRUNCFG2 Bit"]
798    #[inline(always)]
799    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
800        self.variant(SramIf24Apd::ClrPdruncfg2)
801    }
802}
803#[doc = "Array Power\n\nValue on reset: 0"]
804#[cfg_attr(feature = "defmt", derive(defmt::Format))]
805#[derive(Clone, Copy, Debug, PartialEq, Eq)]
806pub enum SramIf25Apd {
807    #[doc = "0: No effect"]
808    NoEffect = 0,
809    #[doc = "1: Clears the PDRUNCFG2 Bit"]
810    ClrPdruncfg2 = 1,
811}
812impl From<SramIf25Apd> for bool {
813    #[inline(always)]
814    fn from(variant: SramIf25Apd) -> Self {
815        variant as u8 != 0
816    }
817}
818#[doc = "Field `SRAM_IF25_APD` writer - Array Power"]
819pub type SramIf25ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf25Apd>;
820impl<'a, REG> SramIf25ApdW<'a, REG>
821where
822    REG: crate::Writable + crate::RegisterSpec,
823{
824    #[doc = "No effect"]
825    #[inline(always)]
826    pub fn no_effect(self) -> &'a mut crate::W<REG> {
827        self.variant(SramIf25Apd::NoEffect)
828    }
829    #[doc = "Clears the PDRUNCFG2 Bit"]
830    #[inline(always)]
831    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
832        self.variant(SramIf25Apd::ClrPdruncfg2)
833    }
834}
835#[doc = "Array Power\n\nValue on reset: 0"]
836#[cfg_attr(feature = "defmt", derive(defmt::Format))]
837#[derive(Clone, Copy, Debug, PartialEq, Eq)]
838pub enum SramIf26Apd {
839    #[doc = "0: No effect"]
840    NoEffect = 0,
841    #[doc = "1: Clears the PDRUNCFG2 Bit"]
842    ClrPdruncfg2 = 1,
843}
844impl From<SramIf26Apd> for bool {
845    #[inline(always)]
846    fn from(variant: SramIf26Apd) -> Self {
847        variant as u8 != 0
848    }
849}
850#[doc = "Field `SRAM_IF26_APD` writer - Array Power"]
851pub type SramIf26ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf26Apd>;
852impl<'a, REG> SramIf26ApdW<'a, REG>
853where
854    REG: crate::Writable + crate::RegisterSpec,
855{
856    #[doc = "No effect"]
857    #[inline(always)]
858    pub fn no_effect(self) -> &'a mut crate::W<REG> {
859        self.variant(SramIf26Apd::NoEffect)
860    }
861    #[doc = "Clears the PDRUNCFG2 Bit"]
862    #[inline(always)]
863    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
864        self.variant(SramIf26Apd::ClrPdruncfg2)
865    }
866}
867#[doc = "Array Power\n\nValue on reset: 0"]
868#[cfg_attr(feature = "defmt", derive(defmt::Format))]
869#[derive(Clone, Copy, Debug, PartialEq, Eq)]
870pub enum SramIf27Apd {
871    #[doc = "0: No effect"]
872    NoEffect = 0,
873    #[doc = "1: Clears the PDRUNCFG2 Bit"]
874    ClrPdruncfg2 = 1,
875}
876impl From<SramIf27Apd> for bool {
877    #[inline(always)]
878    fn from(variant: SramIf27Apd) -> Self {
879        variant as u8 != 0
880    }
881}
882#[doc = "Field `SRAM_IF27_APD` writer - Array Power"]
883pub type SramIf27ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf27Apd>;
884impl<'a, REG> SramIf27ApdW<'a, REG>
885where
886    REG: crate::Writable + crate::RegisterSpec,
887{
888    #[doc = "No effect"]
889    #[inline(always)]
890    pub fn no_effect(self) -> &'a mut crate::W<REG> {
891        self.variant(SramIf27Apd::NoEffect)
892    }
893    #[doc = "Clears the PDRUNCFG2 Bit"]
894    #[inline(always)]
895    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
896        self.variant(SramIf27Apd::ClrPdruncfg2)
897    }
898}
899#[doc = "Array Power\n\nValue on reset: 0"]
900#[cfg_attr(feature = "defmt", derive(defmt::Format))]
901#[derive(Clone, Copy, Debug, PartialEq, Eq)]
902pub enum SramIf28Apd {
903    #[doc = "0: No effect"]
904    NoEffect = 0,
905    #[doc = "1: Clears the PDRUNCFG2 Bit"]
906    ClrPdruncfg2 = 1,
907}
908impl From<SramIf28Apd> for bool {
909    #[inline(always)]
910    fn from(variant: SramIf28Apd) -> Self {
911        variant as u8 != 0
912    }
913}
914#[doc = "Field `SRAM_IF28_APD` writer - Array Power"]
915pub type SramIf28ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf28Apd>;
916impl<'a, REG> SramIf28ApdW<'a, REG>
917where
918    REG: crate::Writable + crate::RegisterSpec,
919{
920    #[doc = "No effect"]
921    #[inline(always)]
922    pub fn no_effect(self) -> &'a mut crate::W<REG> {
923        self.variant(SramIf28Apd::NoEffect)
924    }
925    #[doc = "Clears the PDRUNCFG2 Bit"]
926    #[inline(always)]
927    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
928        self.variant(SramIf28Apd::ClrPdruncfg2)
929    }
930}
931#[doc = "Array Power\n\nValue on reset: 0"]
932#[cfg_attr(feature = "defmt", derive(defmt::Format))]
933#[derive(Clone, Copy, Debug, PartialEq, Eq)]
934pub enum SramIf29Apd {
935    #[doc = "0: No effect"]
936    NoEffect = 0,
937    #[doc = "1: Clears the PDRUNCFG2 Bit"]
938    ClrPdruncfg2 = 1,
939}
940impl From<SramIf29Apd> for bool {
941    #[inline(always)]
942    fn from(variant: SramIf29Apd) -> Self {
943        variant as u8 != 0
944    }
945}
946#[doc = "Field `SRAM_IF29_APD` writer - Array Power"]
947pub type SramIf29ApdW<'a, REG> = crate::BitWriter<'a, REG, SramIf29Apd>;
948impl<'a, REG> SramIf29ApdW<'a, REG>
949where
950    REG: crate::Writable + crate::RegisterSpec,
951{
952    #[doc = "No effect"]
953    #[inline(always)]
954    pub fn no_effect(self) -> &'a mut crate::W<REG> {
955        self.variant(SramIf29Apd::NoEffect)
956    }
957    #[doc = "Clears the PDRUNCFG2 Bit"]
958    #[inline(always)]
959    pub fn clr_pdruncfg2(self) -> &'a mut crate::W<REG> {
960        self.variant(SramIf29Apd::ClrPdruncfg2)
961    }
962}
963#[cfg(feature = "debug")]
964impl core::fmt::Debug for crate::generic::Reg<Pdruncfg2ClrSpec> {
965    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
966        write!(f, "(not readable)")
967    }
968}
969impl W {
970    #[doc = "Bit 0 - Array Power"]
971    #[inline(always)]
972    pub fn sram_if0_apd(&mut self) -> SramIf0ApdW<Pdruncfg2ClrSpec> {
973        SramIf0ApdW::new(self, 0)
974    }
975    #[doc = "Bit 1 - Array Power"]
976    #[inline(always)]
977    pub fn sram_if1_apd(&mut self) -> SramIf1ApdW<Pdruncfg2ClrSpec> {
978        SramIf1ApdW::new(self, 1)
979    }
980    #[doc = "Bit 2 - Array Power"]
981    #[inline(always)]
982    pub fn sram_if2_apd(&mut self) -> SramIf2ApdW<Pdruncfg2ClrSpec> {
983        SramIf2ApdW::new(self, 2)
984    }
985    #[doc = "Bit 3 - Array Power"]
986    #[inline(always)]
987    pub fn sram_if3_apd(&mut self) -> SramIf3ApdW<Pdruncfg2ClrSpec> {
988        SramIf3ApdW::new(self, 3)
989    }
990    #[doc = "Bit 4 - Array Power"]
991    #[inline(always)]
992    pub fn sram_if4_apd(&mut self) -> SramIf4ApdW<Pdruncfg2ClrSpec> {
993        SramIf4ApdW::new(self, 4)
994    }
995    #[doc = "Bit 5 - Array Power"]
996    #[inline(always)]
997    pub fn sram_if5_apd(&mut self) -> SramIf5ApdW<Pdruncfg2ClrSpec> {
998        SramIf5ApdW::new(self, 5)
999    }
1000    #[doc = "Bit 6 - Array Power"]
1001    #[inline(always)]
1002    pub fn sram_if6_apd(&mut self) -> SramIf6ApdW<Pdruncfg2ClrSpec> {
1003        SramIf6ApdW::new(self, 6)
1004    }
1005    #[doc = "Bit 7 - Array Power"]
1006    #[inline(always)]
1007    pub fn sram_if7_apd(&mut self) -> SramIf7ApdW<Pdruncfg2ClrSpec> {
1008        SramIf7ApdW::new(self, 7)
1009    }
1010    #[doc = "Bit 8 - Array Power"]
1011    #[inline(always)]
1012    pub fn sram_if8_apd(&mut self) -> SramIf8ApdW<Pdruncfg2ClrSpec> {
1013        SramIf8ApdW::new(self, 8)
1014    }
1015    #[doc = "Bit 9 - Array Power"]
1016    #[inline(always)]
1017    pub fn sram_if9_apd(&mut self) -> SramIf9ApdW<Pdruncfg2ClrSpec> {
1018        SramIf9ApdW::new(self, 9)
1019    }
1020    #[doc = "Bit 10 - Array Power"]
1021    #[inline(always)]
1022    pub fn sram_if10_apd(&mut self) -> SramIf10ApdW<Pdruncfg2ClrSpec> {
1023        SramIf10ApdW::new(self, 10)
1024    }
1025    #[doc = "Bit 11 - Array Power"]
1026    #[inline(always)]
1027    pub fn sram_if11_apd(&mut self) -> SramIf11ApdW<Pdruncfg2ClrSpec> {
1028        SramIf11ApdW::new(self, 11)
1029    }
1030    #[doc = "Bit 12 - Array Power"]
1031    #[inline(always)]
1032    pub fn sram_if12_apd(&mut self) -> SramIf12ApdW<Pdruncfg2ClrSpec> {
1033        SramIf12ApdW::new(self, 12)
1034    }
1035    #[doc = "Bit 13 - Array Power"]
1036    #[inline(always)]
1037    pub fn sram_if13_apd(&mut self) -> SramIf13ApdW<Pdruncfg2ClrSpec> {
1038        SramIf13ApdW::new(self, 13)
1039    }
1040    #[doc = "Bit 14 - Array Power"]
1041    #[inline(always)]
1042    pub fn sram_if14_apd(&mut self) -> SramIf14ApdW<Pdruncfg2ClrSpec> {
1043        SramIf14ApdW::new(self, 14)
1044    }
1045    #[doc = "Bit 15 - Array Power"]
1046    #[inline(always)]
1047    pub fn sram_if15_apd(&mut self) -> SramIf15ApdW<Pdruncfg2ClrSpec> {
1048        SramIf15ApdW::new(self, 15)
1049    }
1050    #[doc = "Bit 16 - Array Power"]
1051    #[inline(always)]
1052    pub fn sram_if16_apd(&mut self) -> SramIf16ApdW<Pdruncfg2ClrSpec> {
1053        SramIf16ApdW::new(self, 16)
1054    }
1055    #[doc = "Bit 17 - Array Power"]
1056    #[inline(always)]
1057    pub fn sram_if17_apd(&mut self) -> SramIf17ApdW<Pdruncfg2ClrSpec> {
1058        SramIf17ApdW::new(self, 17)
1059    }
1060    #[doc = "Bit 18 - Array Power"]
1061    #[inline(always)]
1062    pub fn sram_if18_apd(&mut self) -> SramIf18ApdW<Pdruncfg2ClrSpec> {
1063        SramIf18ApdW::new(self, 18)
1064    }
1065    #[doc = "Bit 19 - Array Power"]
1066    #[inline(always)]
1067    pub fn sram_if19_apd(&mut self) -> SramIf19ApdW<Pdruncfg2ClrSpec> {
1068        SramIf19ApdW::new(self, 19)
1069    }
1070    #[doc = "Bit 20 - Array Power"]
1071    #[inline(always)]
1072    pub fn sram_if20_apd(&mut self) -> SramIf20ApdW<Pdruncfg2ClrSpec> {
1073        SramIf20ApdW::new(self, 20)
1074    }
1075    #[doc = "Bit 21 - Array Power"]
1076    #[inline(always)]
1077    pub fn sram_if21_apd(&mut self) -> SramIf21ApdW<Pdruncfg2ClrSpec> {
1078        SramIf21ApdW::new(self, 21)
1079    }
1080    #[doc = "Bit 22 - Array Power"]
1081    #[inline(always)]
1082    pub fn sram_if22_apd(&mut self) -> SramIf22ApdW<Pdruncfg2ClrSpec> {
1083        SramIf22ApdW::new(self, 22)
1084    }
1085    #[doc = "Bit 23 - Array Power"]
1086    #[inline(always)]
1087    pub fn sram_if23_apd(&mut self) -> SramIf23ApdW<Pdruncfg2ClrSpec> {
1088        SramIf23ApdW::new(self, 23)
1089    }
1090    #[doc = "Bit 24 - Array Power"]
1091    #[inline(always)]
1092    pub fn sram_if24_apd(&mut self) -> SramIf24ApdW<Pdruncfg2ClrSpec> {
1093        SramIf24ApdW::new(self, 24)
1094    }
1095    #[doc = "Bit 25 - Array Power"]
1096    #[inline(always)]
1097    pub fn sram_if25_apd(&mut self) -> SramIf25ApdW<Pdruncfg2ClrSpec> {
1098        SramIf25ApdW::new(self, 25)
1099    }
1100    #[doc = "Bit 26 - Array Power"]
1101    #[inline(always)]
1102    pub fn sram_if26_apd(&mut self) -> SramIf26ApdW<Pdruncfg2ClrSpec> {
1103        SramIf26ApdW::new(self, 26)
1104    }
1105    #[doc = "Bit 27 - Array Power"]
1106    #[inline(always)]
1107    pub fn sram_if27_apd(&mut self) -> SramIf27ApdW<Pdruncfg2ClrSpec> {
1108        SramIf27ApdW::new(self, 27)
1109    }
1110    #[doc = "Bit 28 - Array Power"]
1111    #[inline(always)]
1112    pub fn sram_if28_apd(&mut self) -> SramIf28ApdW<Pdruncfg2ClrSpec> {
1113        SramIf28ApdW::new(self, 28)
1114    }
1115    #[doc = "Bit 29 - Array Power"]
1116    #[inline(always)]
1117    pub fn sram_if29_apd(&mut self) -> SramIf29ApdW<Pdruncfg2ClrSpec> {
1118        SramIf29ApdW::new(self, 29)
1119    }
1120}
1121#[doc = "Run configuration 2 clear\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pdruncfg2_clr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1122pub struct Pdruncfg2ClrSpec;
1123impl crate::RegisterSpec for Pdruncfg2ClrSpec {
1124    type Ux = u32;
1125}
1126#[doc = "`write(|w| ..)` method takes [`pdruncfg2_clr::W`](W) writer structure"]
1127impl crate::Writable for Pdruncfg2ClrSpec {
1128    type Safety = crate::Unsafe;
1129    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1130    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1131}
1132#[doc = "`reset()` method sets PDRUNCFG2_CLR to value 0"]
1133impl crate::Resettable for Pdruncfg2ClrSpec {
1134    const RESET_VALUE: u32 = 0;
1135}
mimxrt685s_pac/sysctl0/pdruncfg2_clr.rs

mimxrt685s_pac/sysctl0/
pdruncfg2_clr.rs
